【扬中集训 DAY4T3】holiday

【题目链接】

点击打开链接

【算法】

建C棵线段树即可，注意要用前缀和优化

【代码】

这是标程

#include <bits/stdc++.h>
using namespace std;

const int MAXR = , MAXC = , MAXN =  * MAXR + ;

int R, C, Q;
int am0[MAXC][MAXR];
char grid[MAXR][MAXC];

bool mark[MAXN];
int am[MAXN][MAXC];
int change[MAXN][MAXC];

inline void split(int at, int l, int r)
{
    mark[at] = false;
    for (int i = ; i <= C; ++i)
        if (change[at][i] < )
        {
            int got = am0[i][r] - am0[i][l];
            if (change[at][i] == )
            got = r - l - got;
            am[at][i] = got;
        }
    if (l +  != r)
    {
        mark[at *  + ] = true;
        mark[at *  + ] = true;
        for (int i = ; i <= C; ++i)
            if (change[at][i] < )
            {
                change[at *  + ][i] = change[at][i];
                change[at *  + ][i] = change[at][i];
                change[at][i] = ;
            }
    }
}

void update(int at, int l, int r, int nl, int nr, int cols[])
{
    if (mark[at])
        split(at, l, r);
    if (l == nl && r == nr)
    {
        mark[at] = true;
        for (int i = ; i <= C; ++i)
            if (cols[i] < )
                change[at][i] = cols[i];
        split(at, l, r);
        return;
    }
    int m = (l + r) / ;
    if (nr <= m)
        update(at *  + , l, m, nl, nr, cols);
    else if (m <= nl)
        update(at *  + , m, r, nl, nr, cols);
    else
    {
        update(at *  + , l, m, nl, m, cols);
        update(at *  + , m, r, m, nr, cols);
    }
    if (mark[at *  + ])
        split(at *  + , l, m);
    if (mark[at *  + ])
        split(at *  + , m, r);
    for (int i = ; i <= C; ++i) // join
        am[at][i] = am[at *  + ][i] + am[at *  + ][i];
}

void read()
{
    scanf("%d %d %d", &R, &C, &Q);
    for (int i = ; i < R; ++i)
        scanf("%s", grid[i]);
}

void solve()
{
    for (int i = ; i <= C; ++i)
        for (int j = ; j <= R; ++j)
        {
            am0[i][j] = am0[i][j - ];
            if (grid[j - ][i - ] == '')
                ++am0[i][j];
        }
    int cols[MAXC];
    for (int i = ; i < MAXC; ++i)
        cols[i] = ;
    update(, , R, , R, cols);
    int r1, r2, c1, c2, x;
    if (mark[])
        split(, , R);
    for (int i = ; i < Q; ++i)
    {
        scanf("%d %d %d %d %d", &r1, &r2, &c1, &c2, &x);
        for (int j = ; j <= C; ++j)
            if (j >= c1 && j <= c2)
                cols[j] = x;
            else
                cols[j] = ;
        update(, , R, r1 - , r2, cols);
        if (mark[])
            split(, , R);
        int ans = ;
        for (int i = ; i <= C; ++i)
            ans += am[][i];
        printf("%d\n", ans);
    }
}

int main()
{
    read();
    solve();
    return ;
}

这是我的程序

#include<bits/stdc++.h>
using namespace std;
#define MAXR 50000
#define MAXC 15
#define MAXQ 1000

struct SegmentTree {
        int l,r,opt,sum;
} tree[MAXC+][MAXR*+];

int i,j,R,C,Q,R1,R2,C1,C2,X,ans;
char ch;
int mat[MAXR+][MAXC+],sum[MAXR+][MAXC+];

template <typename T> inline void read(T &x) {
    int f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }
    for (; isdigit(c); c = getchar()) x = x *  + c - '';
    x *= f;
}

template <typename T> inline void write(T x) {
    if (x < ) { putchar('-'); x = -x; }
    if (x > ) write(x/);
    putchar(x%+'');
}

template <typename T> inline void writeln(T x) {
    write(x);
    puts("");
}

inline void build(int pos,int index,int l,int r) {
        int mid;
        tree[pos][index].l = l; tree[pos][index].r = r;
        tree[pos][index].sum = r - l +  - sum[r][pos] + sum[l-][pos];
        tree[pos][index].opt = ;
        if (l == r) return;
        mid = (l + r) >> ;
        build(pos,index*,l,mid); build(pos,index*+,mid+,r);
}

inline void pushdown(int pos,int index) {
        int l = tree[pos][index].l,
               r = tree[pos][index].r;
        if (l == r) return;
        tree[pos][index*].opt = tree[pos][index].opt;
        tree[pos][index*+].opt = tree[pos][index].opt;
        l = tree[pos][index*].l,
        r = tree[pos][index*].r;
        if (!tree[pos][index].opt) tree[pos][index*].sum = r - l +  - sum[r][pos] + sum[l-][pos];
        else tree[pos][index*].sum = sum[r][pos] - sum[l-][pos];
        l = tree[pos][index*+].l,
        r = tree[pos][index*+].r;
        if (!tree[pos][index].opt) tree[pos][index*+].sum = r - l +  - sum[r][pos] + sum[l-][pos];
        else tree[pos][index*+].sum = sum[r][pos] - sum[l-][pos];
}

inline void pushup(int pos,int index) {
        tree[pos][index].sum = tree[pos][index*].sum + tree[pos][index*+].sum;
        if ((tree[pos][index*].opt == -) || (tree[pos][index*+].opt == -)) {
                tree[pos][index].opt = -;
                return;
        }
        if (tree[pos][index*].opt != tree[pos][index*+].opt) {
                tree[pos][index].opt = -;
                return;
        }
        tree[pos][index].opt = tree[pos][index*].opt;
}

inline void modify(int pos,int index,int l,int r,int val) {
         int mid;
         if (tree[pos][index].opt != -) pushdown(pos,index);
        if ((tree[pos][index].l == l) && (tree[pos][index].r == r)) {
                tree[pos][index].opt = val;
                if (!val) tree[pos][index].sum = r - l +  - sum[r][pos] + sum[l-][pos];
                else tree[pos][index].sum = sum[r][pos] - sum[l-][pos];
        }    else {
                mid = (tree[pos][index].l + tree[pos][index].r) >> ;
                if (mid >= r) modify(pos,index*,l,r,val);
                else if (mid +  <= l) modify(pos,index*+,l,r,val);
                else {
                        modify(pos,index*,l,mid,val);
                        modify(pos,index*+,mid+,r,val);
                }
                pushup(pos,index);
        }
}

int main() {

        read(R); read(C); read(Q);
        for (i = ; i <= R; i++) {
                for (j = ; j <= C; j++) {
                        ch = getchar();
                        mat[i][j] = ch - '';
                }
                getchar();
        }

        for (i = ; i <= C; i++) {
                for (j = ; j <= R; j++) {
                        sum[j][i] = sum[j-][i] + mat[j][i];
                }
        }

        for (i = ; i <= C; i++) build(i,,,R);

        while (Q--) {
             ans = ;
             read(R1); read(R2); read(C1); read(C2); read(X);
             for (i = C1; i <= C2; i++) modify(i,,R1,R2,X);
             for (i = ; i <= C; i++) ans += tree[i][].sum;
             writeln(ans);
        }

        return ;

}