暂存

线性表

#include <stdio.h>
#include <stdlib.h>

const int N= 110;

typedef int datatype;

typedef struct {
    datatype a[N];
    int sz;
}List;

void init(List *a) {
    a->sz = 0;
}

void input(List *a) {
    datatype x;
    init(a);
    printf("输入一组数，以0结束符\n");
    while(scanf("%d", &x) && x) {
        a->a[a->sz++] = x;
    }
}

void inputfromfile(List *a, char *c) {
    FILE *fp = fopen(c, "r");
    init(a);
    if(fp) {
        while(!feof(fp)) {
            fscanf(fp, "%d", &a->a[a->sz++]);
        }
        fclose(fp);
    }
}

void print(List a) {
    for(int i = 0; i < a.sz; i++) {
        printf("%5d%c", a.a[i], i && i % 10 == 0 ? '\n' : ' ');
    }
}

void rever(List *a) {
    for(int l = 0, r = a->sz - 1; l < r; l++, r--) {
        int temp = a->a[l];
        a->a[l] = a->a[r];
        a->a[r] = temp;
    }
}

void sqrit(List *a, List *b, List *c) {
    init(b), init(c);
    for(int i = 0; i < a->sz; i++) {
        if(a->a[i] & 1) {
            b->a[b->sz++] = a->a[i];
        }
        else {
            c->a[c->sz++] = a->a[i];
        }
    }
}

void mergt(List *a, List *b, List *c) {
    int i = 0, j = 0;
    init(c);
    while(i < a->sz && j < b->sz) {
        if(a->a[i] < b->a[j]) {
            c->a[c->sz++] = a->a[i++];
        }
        else {
            c->a[c->sz++] = b->a[j++];
        }
    }
    while(i < a->sz) {
        c->a[c->sz++] = a->a[i++];
    }
    while(j < b->sz) {
        c->a[c->sz++] = b->a[j++];
    }
}

void inter(List *a, List *b, List *c) {
    init(c);
    for(int i = 0; i < a->sz; i++) {
        int flag = 0;
        for(int j = 0; j < b->sz; j++) {
            if(a->a[i] == b->a[j]) {
                flag = 1;
                break;
            }
        }
        if(flag) {
            c->a[c->sz++] = a->a[i];
        }
    }
}

void partion(List *a) {
    int l = 0, r = a->sz - 1;
    while(l < r) {
        while(a->a[l] & 1 && l < r) l++;
        if(l == r) break;
        while(a->a[r] % 2 == 0 && l < r) r--;
        if(l == r) break;
        int temp = a->a[l];
        a->a[l] = a->a[r];
        a->a[r] = temp;
    }
}

int main() {
    List a, b, c;
    input(&a);
    sqrit(&a, &b, &c);
    print(b);
    printf("\n");
    print(c);
    return 0;
}

链表

#include <stdio.h>
#include <iostream>

using namespace std;

struct node {
    int date;
    node *next;
};

typedef node *Node;

Node creat_by_front() {
    Node head, s;
    int x;
    head = NULL;
    puts("input:");
    while(cin >> x && x) {
        s = (Node)malloc(sizeof(node));
        s->date = x;
        s->next = head;
        head = s;
    }
    return head;
}

Node creat_by_tail() {
    Node head, r, s;
    int x;
    head = r = NULL;
    puts("input:");
    while(cin >> x && x) {
        s = (Node)malloc(sizeof(node));
        s->date = x;
        if(head == NULL) {
            head = s;
        }
        else {
            r->next = s;
        }
        r = s;
    }
    if(r) r->next = NULL;
    return head;
}

void print(Node a) {
    while(a) {
        cout << a->date << " ";
        a = a->next;
    }
    puts("");
}

Node Delnode(Node head) {
    Node p = head;
    while(p) {
        head = p->next;
        free(p);
        p = head;
    }
    return p;
}

Node del_x(Node head, int value) {
    if(!head) {
        puts("is_empty");
        return head;
    }
    Node p1, p2;
    p2 = NULL;
    p1 = head;
    while(p1 && p1->date != value) {
        p2 = p1;
        p1 = p1->next;
    }
    if(!p1) {
        return head;
    }
    if(!p2) {
        return head->next;
    }
    p2->next = p1->next;
    return head;
}

Node insert(Node head, int value) {
    Node p1, p2;
    p1 = head, p2 = NULL;
    while(p1->date < value && p1) {
        p2 = p1;
        p1 = p1->next;
    }
    if(!p2) {
        p2 = (Node)malloc(sizeof(node));
        p2->date = value;
        p2->next = head;
        return p2;
    }
    Node now = (Node)malloc(sizeof(node));
    now->date = value;
    p2->next = now;
    now->next = p1;
    return head;
}

Node delallx(Node head, int value) {
    if(!head) {
        puts("is_empty");
        return head;
    }
    Node p1, p2;
    p2 = NULL;
    p1 = head;
    while(p1) {
        if(p1->date == value) {
            if(!p2) {
                head = head->next;
                p1 = p1->next;
            }
            else {
                p2->next = p1->next;
                p1 = p1->next;
            }
        }
        else {
            p2 = p1;
            p1 = p1->next;
        }
    }
    return head;
}

int main() {
    Node a = creat_by_tail();
    print(a);
    a = delallx(a, 2);
    print(a);
    return 0;
}

#include<iostream>
#include<cstdio>
using namespace std;
const int maxm=2e3+5;
const int mod=1e4+7;
const int p=2e3;
int a[maxm][maxm];
int temp[maxm];
int nmax,mmax;
int n,m;
struct Tree{
    int val[maxm<<2];
    int cnt[maxm<<2];
    int laz[maxm<<2];
    void pp(int node){
        val[node]=val[node*2]+val[node*2+1];
        val[node]%=mod;
        cnt[node]=cnt[node*2]+cnt[node*2+1];
    }
    void pd(int node){
        if(laz[node]){
            laz[node*2]=laz[node];
            laz[node*2+1]=laz[node];
            cnt[node*2]=0;
            cnt[node*2+1]=0;
            val[node*2]=0;
            val[node*2+1]=0;
            laz[node]=0;
        }
    }
    void build(int l,int r,int node){
        cnt[node]=val[node]=0;
        laz[node]=0;
        if(l==r)return ;
        int mid=(l+r)/2;
        build(l,mid,node*2);
        build(mid+1,r,node*2+1);
        pp(node);
    }
    int ask_cnt(int st,int ed,int l,int r,int node){
        if(st>ed)return 0;
        if(st<=l&&ed>=r)return cnt[node];
        pd(node);
        int mid=(l+r)/2;
        int ans=0;
        if(st<=mid)ans+=ask_cnt(st,ed,l,mid,node*2);
        if(ed>mid)ans+=ask_cnt(st,ed,mid+1,r,node*2+1);
        return ans;
    }
    int ask_val(int st,int ed,int l,int r,int node){
        if(st>ed)return 0;
        if(st<=l&&ed>=r)return val[node];
        pd(node);
        int mid=(l+r)/2;
        int ans=0;
        if(st<=mid)ans+=ask_val(st,ed,l,mid,node*2);
        if(ed>mid)ans+=ask_val(st,ed,mid+1,r,node*2+1);
        ans%=mod;
        return ans;
    }
    void update(int x,int v,int l,int r,int node){
        if(l==r){
            cnt[node]+=v;
            cnt[node]=min(cnt[node],mmax);
            val[node]=1ll*cnt[node]*l%mod;
            return ;
        }
        pd(node);
        int mid=(l+r)/2;
        if(x<=mid)update(x,v,l,mid,node*2);
        else update(x,v,mid+1,r,node*2+1);
        pp(node);
    }
    void del(int st,int ed,int l,int r,int node){
        if(st>ed)return ;
        if(st<=l&&ed>=r){
            cnt[node]=0;
            val[node]=0;
            laz[node]=1;
            return ;
        }
        pd(node);
        int mid=(l+r)/2;
        if(st<=mid)del(st,ed,l,mid,node*2);
        if(ed>mid)del(st,ed,mid+1,r,node*2+1);
        pd(node);
    }
}T;
signed main(){
    scanf("%d%d",&n,&m);
    scanf("%d%d",&nmax,&mmax);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&a[i][j]);
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        T.build(0,p,1);
        for(int j=1;j<=m;j++){
            if(a[i][j]){
                if(a[i-1][j])temp[j]++;
                else temp[j]=1;
                temp[j]=min(temp[j],nmax);
            }else{
                temp[j]=0;
            }
        }
        for(int j=1;j<=m;j++){
            int x=temp[j];
            int ma_cnt=T.ask_cnt(x+1,p,0,p,1);
            T.del(x+1,p,0,p,1);
            T.update(x,ma_cnt+1,0,p,1);
            ans+=T.ask_val(0,min(mmax,x),0,p,1);
            ans%=mod;
        }
    }
    cout<<ans<<endl;
    return 0;
}