UVA 11992

Fast Matrix Operations

There is a matrix containing at most 10⁶ elements divided into r rows and c columns. Each element has a location (x,y) where 1<=x<=r,1<=y<=c. Initially, all the elements are zero. You need to handle four kinds of operations:

1 x1 y1 x2 y2 v

Increment each element (x,y) in submatrix (x1,y1,x2,y2) by v (v>0)

2 x1 y1 x2 y2 v

Set each element (x,y) in submatrix (x1,y1,x2,y2) to v

3 x1 y1 x2 y2

Output the summation, min value and max value of submatrix (x1,y1,x2,y2)

In the above descriptions, submatrix (x1,y1,x2,y2) means all the elements (x,y) satisfying x1<=x<=x2 and y1<=x<=y2. It is guaranteed that 1<=x1<=x2<=r, 1<=y1<=y2<=c. After any operation, the sum of all the elements in the matrix does not exceed 10⁹.

Input

There are several test cases. The first line of each case contains three positive integers r, c, m, where m (1<=m<=20,000) is the number of operations. Each of the next m lines contains a query. There will be at most twenty rows in the matrix. The input is terminated by end-of-file (EOF). The size of input file does not exceed 500KB.

Output

For each type-3 query, print the summation, min and max.

Sample Input

4 4 8
1 1 2 4 4 5
3 2 1 4 4
1 1 1 3 4 2
3 1 2 4 4
3 1 1 3 4
2 2 1 4 4 2
3 1 2 4 4
1 1 1 4 3 3

Output for the Sample Input

45 0 5
78 5 7
69 2 7
39 2 7

这两天一直再搞线段树，没写好一道题，加上学业一下子忙起来，没来得及更新博客，今天终于把一道题写好了.此题是线段树的综合应用，题很好,对区间维护要求大.要特别注意区间累加和重置操作的关系，有无影响。

/*
* @author  Panoss
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<vector>
#include<ctime>
#include<stack>
#include<queue>
#include<list>
using namespace std;
#define DBG 0
#define fori(i,a,b) for(int i = (a); i < (b); i++)
#define forie(i,a,b) for(int i = (a); i <= (b); i++)
#define ford(i,a,b) for(int i = (a); i > (b); i--)
#define forde(i,a,b) for(int i = (a); i >= (b); i--)
#define forls(i,a,b,n) for(int i = (a); i != (b); i = n[i])
#define mset(a,v) memset(a, v, sizeof(a))
#define mcpy(a,b) memcpy(a, b, sizeof(a))
#define dout  DBG && cerr << __LINE__ << " >>| "
#define checkv(x) dout << #x"=" << (x) << " | "<<endl
#define checka(array,a,b) if(DBG) { 
    dout << #array"[] | " << endl; 
    forie(i, a, b) cerr << "[" << i << "]=" << array[i] << " |" << ((i - (a)+1) % 5 ? " " : "
"); 
if (((b)-(a)+1) % 5) cerr << endl; 
}
#define redata(T, x) T x; cin >> x
#define MIN_LD -2147483648
#define MAX_LD  2147483647
#define MIN_LLD -9223372036854775808
#define MAX_LLD  9223372036854775807
#define MAX_INF 18446744073709551615
inline int  reint() { int d; scanf("%d", &d); return d; }
inline long relong() { long l; scanf("%ld", &l); return l; }
inline char rechar() { scanf(" "); return getchar(); }
inline double redouble() { double d; scanf("%lf", &d); return d; }
inline string restring() { string s; cin >> s; return s; }

#define MAX_TREE_NODE 50000         ///树结点个数

struct Segment_Tree
{
    int L, R;                       ///左,右区间
    long min_value, max_value;      ///区间最小值，最大值;
    long sum;                       ///区间和
    bool add_flag;                  ///区间是否增个某个数值标志
    long add_value;                 ///区间增量
    bool set_flag;                  ///区间是否重置为某个数值标志
    long set_value;                 ///设置值
    struct Segment_Tree * left;     ///左儿子
    struct Segment_Tree * right;    ///右儿子
};


Segment_Tree Tree[25][2 * MAX_TREE_NODE + 5];

int Tree_node_number = 1;                                   ///结点编号,1号为根结点

int Mid(Segment_Tree * root) { return (root->L + (root->R - root->L) / 2); }

void Build_Tree(Segment_Tree * root, int left, int right,int k)  ///建树,第k棵树
{
    root->L = left;
    root->R = right;
    root->max_value = MIN_LD;
    root->min_value = MAX_LD;
    root->sum = 0;
    root->add_value = 0;
    root->add_flag = false;
    root->set_value = 0;
    root->set_flag = false;
    root->left = NULL;
    root->right = NULL;
    if (left == right) return;
    Tree_node_number++;
    root->left = Tree[k] + Tree_node_number;
    Tree_node_number++;
    root->right = Tree[k] + Tree_node_number;
    Build_Tree(root->left, left, (left + right) / 2,k);
    Build_Tree(root->right, (left + right) / 2 + 1, right,k);
}

void updata(Segment_Tree * root)   ///维护根结点的信息
{
    if (root->R > root->L)
    {
        root->max_value = max(root->left->max_value, root->right->max_value);
        root->min_value = min(root->left->min_value, root->right->min_value);
        root->sum = root->left->sum + root->right->sum;
    }

    if (root->set_flag)
    {
        root->max_value = root->set_value;
        root->min_value = root->set_value;
        root->sum = root->set_value * (root->R - root->L + 1);
    }

    if (root->add_flag)
    {
        root->max_value += root->add_value;
        root->min_value += root->add_value;
        root->sum += root->add_value * (root->R - root->L + 1);
    }

}

void pushdown(Segment_Tree *root)   ///传递标记
{
    if (root->set_flag)
    {
        root->left->set_value = root->set_value;
        root->left->set_flag = true;
        root->left->add_value = 0;
        root->left->add_flag = false;

        root->right->set_value = root->set_value;
        root->right->set_flag = true;
        root->right->add_value = 0;
        root->right->add_flag = false;

        root->set_flag = false;
        root->set_value = 0;
    }

    if (root->add_flag)
    {
        root->left->add_value += root->add_value;
        root->left->add_flag = true;

        root->right->add_value += root->add_value;
        root->right->add_flag = true;

        root->add_flag = false;
        root->add_value = 0;
    }

}


void Add_value(Segment_Tree * root, int i, int j, int value)  ///为区间i,j每个元素加value
{
    if (i <= root->L && root->R <= j)
    {
        root->add_flag = true;
        root->add_value += value;
    }
    else
    {
        pushdown(root);

        if (i <= Mid(root))
        {
            Add_value(root->left, i, j, value);
        }
        else
        {
            updata(root->left);
        }
        if (Mid(root) < j)
        {
            Add_value(root->right, i, j, value);
        }
        else
        {
            updata(root->right);
        }
    }

    updata(root); 
}

void Set_value(Segment_Tree * root, int i, int j, int value)    ///重置区间i,j每个元素为value
{
    if (i <= root->L && root->R <= j)
    {
        root->set_flag = true;
        root->set_value = value;
        root->add_value = 0;             
        root->add_flag = false;
    }
    else
    {
        pushdown(root);

        if (i <= Mid(root))
        {
            Set_value(root->left, i, j, value);
        }
        else
        {
            updata(root->left);
        }
        if (Mid(root) < j)
        {
            Set_value(root->right, i, j, value);
        }
        else
        {
            updata(root->right);
        }
    }

    updata(root);
}


void Change_node(Segment_Tree * root, int number, int value)   ///修改数据 a[number] = value;
{
    if (root->L == number && root->R == number)   ///叶子结点,直接修改,更新最大值最小值为value,区间和也是value
    {
        root->sum = root->max_value = root->min_value = value;
    }
    else
    {
        if (number <= Mid(root))
        {
            Change_node(root->left, number, value);
        }
        else
        {
            Change_node(root->right, number, value);
        }

        updata(root);
    }
}


long Query_min_value(Segment_Tree * root, int i, int j,int add_total)     ///查询区间i,j最小值
{
    long ans_min = MAX_LD;

    if (root->set_flag)
    {
        long total_value = root->set_value + add_total;
        if (root->add_flag) total_value += root->add_value;

        ans_min = min(ans_min, total_value);
    }

    else if (i <= root->L && root->R <= j)
    {
        ans_min = min(ans_min, root->min_value + add_total);
    }
    else
    {
        if (root->add_flag)
        {
            long left_min = MAX_LD, right_min = MAX_LD;
            if (i <= Mid(root))
                left_min = Query_min_value(root->left, i, j, add_total + root->add_value);
            if (j > Mid(root))
                right_min = Query_min_value(root->right, i, j, add_total + root->add_value);
            ans_min = min(left_min, right_min);
        }
        else
        {
            long left_min = MAX_LD, right_min = MAX_LD;
            if (i <= Mid(root))
                left_min = Query_min_value(root->left, i, j, add_total);
            if (j > Mid(root))
                right_min = Query_min_value(root->right, i, j, add_total);
            ans_min = min(left_min, right_min);
        }

    }
    return  ans_min;
}

long Query_max_value(Segment_Tree * root, int i, int j,int add_total)    ///查询区间i,j最大值
{

    long ans_max = MIN_LD;

    if (root->set_flag)
    {
        long total_value = root->set_value + add_total;
        if (root->add_flag) total_value += root->add_value;

        ans_max = max(ans_max, total_value);
    }

    else if (i <= root->L && root->R <= j)
    {
        ans_max = max(ans_max, root->max_value + add_total);
    }
    else
    {
        if (root->add_flag)
        {
            long left_max = MIN_LD, right_max = MIN_LD;
            if (i <= Mid(root))
                left_max = Query_max_value(root->left, i, j, add_total + root->add_value);
            if (j > Mid(root))
                right_max = Query_max_value(root->right, i, j, add_total + root->add_value);
            ans_max = max(left_max, right_max);
        }
        else
        {
            long left_max = MIN_LD, right_max = MIN_LD;
            if (i <= Mid(root))
                left_max = Query_max_value(root->left, i, j, add_total);
            if (j > Mid(root))
                right_max = Query_max_value(root->right, i, j, add_total);
            ans_max = max(left_max, right_max);
        }
    }
    return  ans_max;
}

long Get_sum(Segment_Tree *root, int i, int j, int add_total)   ///求区间i,j的和
{
    long ans_sum = 0;

    if (root->set_flag)
    {
        long value_total = root->set_value + add_total;
        if (root->add_flag) value_total += root->add_value;

        ans_sum += value_total * ( min(root->R,j) - max(root->L,i) + 1);


    }

    else if (i <= root->L && root->R <= j)
    {
        ans_sum += root->sum + add_total * (root->R - root->L + 1);
    }
    else
    {
        if (root->add_flag)
        {
            if(i <= Mid(root) )
                ans_sum += Get_sum(root->left, i, j, add_total + root->add_value);
            if(Mid(root) < j)
                ans_sum += Get_sum(root->right, i, j, add_total + root->add_value);
        }
        else
        {
            if (i <= Mid(root))
                ans_sum += Get_sum(root->left, i, j, add_total );
            if (Mid(root) < j)
                ans_sum += Get_sum(root->right, i, j, add_total );
        }
    }
    return ans_sum;
}

int main()
{
    int r, c, m, op;
    int x1, y1, x2, y2, value;
    while (scanf("%d%d%d", &r, &c, &m) == 3)
    {
        mset(Tree,0);

        forie(i, 1, r)    ///为每一行建一棵线段树
        {
            Tree_node_number = 1;
            Build_Tree(Tree[i] + 1, 1, c, i);
        }
        forie(i, 1, r)    ///为每一棵线段树插入每个元素为0
        {
            Set_value(Tree[i] + 1, 1, c, 0);///直接每行全部清0,或者调用Chang_node修改数据
        }

        forie(T, 1, m)
        {
            scanf("%d", &op);
            if (op == 1)
            {
                scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &value);
                forie(i, x1, x2)
                {
                    Add_value(Tree[i] + 1, y1, y2, value);
                }
            }
            if (op == 2)
            {
                scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &value);
                forie(i, x1, x2)
                {
                    Set_value(Tree[i] + 1, y1, y2, value);
                }
            }
            if (op == 3)
            {
                long ans_sum = 0, ans_min = MAX_LD, ans_max = MIN_LD;

                scanf("%d%d%d%d", &x1, &y1, &x2, &y2);

                forie(i, x1, x2)
                {
                    ans_sum += Get_sum(Tree[i] + 1, y1, y2, 0);
                }

                forie(i, x1, x2)
                {
                    ans_min = min(ans_min, Query_min_value(Tree[i] + 1, y1, y2, 0));
                }

                forie(i, x1, x2)
                {
                    ans_max = max(ans_max, Query_max_value(Tree[i] + 1, y1, y2, 0));
                }

                printf("%ld %ld %ld
", ans_sum, ans_min, ans_max);
            }
        }
    }
    return 0;
}