Problem:
Problem J: Matrix
Problem
長さ$H$の数列$A$と長さ$W$の数列$B$が与えられる。
$H$行$W$列からなる行列$C$を以下のように定義する。
$ C_{i,j} = A_i \times B_j (1 \leq i \leq H, 1 \leq j \leq W) $
以下の四種類のクエリを合計$Q$回処理せよ。
クエリ1
$1$ $a$ $b$ $v$
$ A_i ( a \leq i \leq b) $に$v$を加える
クエリ2
$2$ $c$ $d$ $v$
$ B_j ( c \leq j \leq d) $に$v$を加える
クエリ3
$3$ $a$ $b$ $c$ $d$
$ C_{i,j} ( a \leq i \leq b, c \leq j \leq d) $の最小値とその個数を出力する
クエリ4
$4$ $a$ $b$ $c$ $d$
$ C_{i,j} ( a \leq i \leq b, c \leq j \leq d) $の最大値とその個数を出力する
詳しくはサンプル入出力を参考にせよ。
Input
入力は以下の形式で与えられる。
$H$ $W$ $Q$
$A_1$ $A_2$ ... $A_H$
$B_1$ $B_2$ ... $B_W$
$query_1$
$query_2$
...
$query_Q$
各クエリは以下の四種類のいずれかの形式で与えられる。
$1$ $a$ $b$ $v$
$2$ $c$ $d$ $v$
$3$ $a$ $b$ $c$ $d$
$4$ $a$ $b$ $c$ $d$
入力はすべて整数で与えられる。
1行目に$H$, $W$, $Q$が空白区切りで与えられる。
2行目に数列$A$の要素$A_i$($1 \leq i \leq H$)が空白区切りで与えられる。
3行目に数列$B$の要素$B_j$($1 \leq j \leq W$)が空白区切りで与えられる。
4行目以降の$Q$行にクエリが改行区切りで与えられる。
各クエリ内の数値は全て空白区切りである。
Constraints
入力は以下の条件を満たす。
$1 \leq H, W, Q\leq 10^5 $
$-1000 \leq A_i \leq 1000 $
$-1000 \leq B_j \leq 1000 $
各クエリについて、入力は以下の条件を満たす。
$1 \leq a \leq b \leq H$
$1 \leq c \leq d \leq W$
$-1000 \leq v \leq 1000$
Output
各クエリ3及びクエリ4について、値と個数を空白区切りで一行に出力せよ。
Sample Input 1
4 4 7
1 2 3 4
1 2 3 4
3 2 3 2 3
4 2 3 2 3
3 1 1 1 1
4 1 1 1 1
1 1 1 1
3 1 4 1 2
4 2 3 2 4
Sample Output 1
4 1
9 1
1 1
1 1
2 2
12 1
クエリ1, 2で指定されている範囲は以下の画像の緑色に塗られた領域である。
クエリ3, 4で指定されている範囲は以下の画像の橙色に塗られた領域である。
クエリ5によって$A_1$に1が加えられる。
クエリ6で指定されている範囲は以下の画像の水色に塗られた領域である。
クエリ7で指定されている範囲は以下の画像の紫色に塗られた領域である。
Sample Input 2
4 4 6
1 1 1 1
1 1 1 1
3 1 4 1 4
4 1 4 1 4
1 2 3 1
2 2 3 1
3 1 4 1 4
4 1 4 1 4
Sample Output 2
1 16
1 16
1 4
4 4
初期状態の$C$は以下のようになる。
クエリ3, 4以後の$C$は以下のようになる。
Sample Input 3
4 4 7
0 1 0 1
1 0 1 0
3 2 4 1 3
4 1 4 1 4
1 1 4 -1
3 1 3 1 3
1 3 3 2
2 3 3 -2
3 2 4 2 4
Sample Output 3
0 5
1 4
-1 4
-1 1
Sample Input 4
36 4 20
-523 -460 -536 -885 652 782 513 -558 -521 -808 124 -708 -943 52 -856 -755 -958 913 380 -767 373 -731 -492 213 538 392 -39 509 -840 135 78 -285 -241 522 -572 -915
-691 -16 812 -385
4 7 17 4 4
3 24 33 1 1
4 3 35 2 4
3 28 32 4 4
2 3 3 438
3 7 15 1 1
4 2 17 4 4
3 24 28 2 4
4 15 16 4 4
4 18 29 1 1
3 24 27 2 4
2 2 3 -828
3 18 23 3 3
1 27 31 -701
2 2 3 298
1 21 32 237
2 3 3 -71
1 14 29 772
4 13 19 3 3
3 19 34 1 2
Sample Output 4
368830 1
-371758 1
741356 1
-195965 1
-354483 1
368830 1
-207130 1
329560 1
580440 1
-207130 1
-323674 1
1093565 1
-1068977 1

Submitted solutions:

code_snippet: #include<bits/stdc++.h> 
using namespace std;
using ll=long long;

#include<atcoder/lazysegtree>
using namespace atcoder;

struct S{
	ll v,n;
};

S opm(S a,S b){
	if(a.v==b.v){
		a.n+=b.n;
		return a;
	}
	else if(a.v<b.v)return a;
	else return b;
}
S em(){return {ll(1e18),0};}
S opM(S a,S b){
	if(a.v==b.v){
		a.n+=b.n;
		return a;
	}
	else if(a.v>b.v)return a;
	else return b;
}
S eM(){return {ll(-1e18),0};}
S mapping(ll a,S b){
	b.v+=a;
	return b;
}
ll add(ll a,ll b){return a+b;}
ll id(){return 0;}


int main(){
	
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	ll H,W,Q;
	cin>>H>>W>>Q;
	vector<S> A(H),B(W);
	for(int i=0;i<H;i++){
		ll a;
		cin>>a;
		A[i]={a,1};
	}
	for(int i=0;i<W;i++){
		ll a;
		cin>>a;
		B[i]={a,1};
	}
	lazy_segtree<S,opm,em,ll,mapping,add,id> segmA(A),segmB(B);
	lazy_segtree<S,opM,eM,ll,mapping,add,id> segMA(A),segMB(B);
	for(int q=0;q<Q;q++){
		int t,a,b;
		cin>>t>>a>>b;
		if(t==1){
			ll v;
			cin>>v;
			a--;
			segmA.apply(a,b,v);
			segMA.apply(a,b,v);
		}
		else if(t==2){
			ll v;
			cin>>v;
			a--;
			segmB.apply(a,b,v);
			segMB.apply(a,b,v);
		}
		else if(t==3){
			int c,d;
			cin>>c>>d;
			a--,c--;
			ll an=1e18,num=0;
			for(int i:{0,1}){
				if(i==1&&segmA.prod(a,b).v==segMA.prod(a,b).v)continue;
				for(int j:{0,1}){
					if(j==1&&segmB.prod(c,d).v==segMB.prod(c,d).v)continue;
					S P,Q;
					if(i)P=segmA.prod(a,b);
					else P=segMA.prod(a,b);
					if(j)Q=segmB.prod(c,d);
					else Q=segMB.prod(c,d);
					if(P.v*Q.v<an){
						an=P.v*Q.v;
						num=0;
					}
					if(P.v*Q.v==an){
						num+=P.n*Q.n;
					}
				}
			}
			if(an==0){
				ll s=b-a,t=d-c;
				if(segmA.prod(a,b).v==0)s-=segmA.prod(a,b).n;
				else if(segMA.prod(a,b).v==0)s-=segMA.prod(a,b).n;
				if(segmB.prod(c,d).v==0)t-=segmB.prod(c,d).n;
				else if(segMB.prod(c,d).v==0)t-=segMB.prod(c,d).n;
				num=ll(b-a)*ll(d-c)-s*t;
			}
			cout<<an<<" "<<num<<endl;
		}
		else{
			int c,d;
			cin>>c>>d;
			a--,c--;
			ll an=-1e18,num=0;
			for(int i:{0,1}){
				if(i==1&&segmA.prod(a,b).v==segMA.prod(a,b).v)continue;
				for(int j:{0,1}){
					if(j==1&&segmB.prod(c,d).v==segMB.prod(c,d).v)continue;
					
					S P,Q;
					if(i)P=segmA.prod(a,b);
					else P=segMA.prod(a,b);
					if(j)Q=segmB.prod(c,d);
					else Q=segMB.prod(c,d);
					// cout<<P.v<<"m"<<P.n<<" "<<Q.v<<" "<<Q.n<<endl;
					if(P.v*Q.v>an){
						an=P.v*Q.v;
						num=0;
					}
					if(P.v*Q.v==an){
						num+=P.n*Q.n;
					}
					
				}
			}
			if(an==0){
				ll s=b-a,t=d-c;
				if(segmA.prod(a,b).v==0)s-=segmA.prod(a,b).n;
				else if(segMA.prod(a,b).v==0)s-=segMA.prod(a,b).n;
				if(segmB.prod(c,d).v==0)t-=segmB.prod(c,d).n;
				else if(segMB.prod(c,d).v==0)t-=segMB.prod(c,d).n;
				num=ll(b-a)*ll(d-c)-s*t;
			}
			cout<<an<<" "<<num<<endl;
		}
	}
}
accuracy: 1
time_ms: 140
memory_kb: 26604
final_rank: 2

code_snippet: #include<iostream>
#include<vector>

using namespace std;
const int N = 1e5 + 10;
const int INF = 1e9 + 7;

struct Node {
    int mn, mx, cmn, cmx;
    Node() {
        mn = INF, mx = -INF, cmn = 0, cmx = 0;
    }
    Node(int x) {
        mn = mx = x, cmn = cmx = 1;
    }
};

Node mrg(Node t1, Node t2) {
    Node ans;

    if(t1.mn < t2.mn) ans.mn = t1.mn, ans.cmn = t1.cmn;
    else if(t1.mn == t2.mn) ans.mn = t1.mn, ans.cmn = t1.cmn + t2.cmn;
    else ans.mn = t2.mn, ans.cmn = t2.cmn;

    if(t1.mx > t2.mx) ans.mx = t1.mx, ans.cmx = t1.cmx;
    else if(t1.mx == t2.mx) ans.mx = t1.mx, ans.cmx = t1.cmx + t2.cmx;
    else ans.mx = t2.mx, ans.cmx = t2.cmx;

    return ans;
}

struct SegTree {
    vector<Node> tree;
    vector<int> d;

    SegTree() {
        tree.resize(N * 4, Node());
        d.resize(N * 4, 0);
    }

    void build(int tind, int l, int r, vector<int> &a) {
        if(r - l == 1) {
            tree[tind] = Node(a[l]);
            return;
        }
        int m = (r + l) >> 1;
        build(tind * 2 + 1, l, m, a);
        build(tind * 2 + 2, m, r, a);
        tree[tind] = mrg(tree[tind * 2 + 1], tree[tind * 2 + 2]);
    }

    void push(int tind, int l, int r) {
        if(d[tind] == 0) return;
        tree[tind].mn += d[tind], tree[tind].mx += d[tind];
        if(r - l > 1) {
            d[tind * 2 + 1] += d[tind];
            d[tind * 2 + 2] += d[tind];
        }
        d[tind] = 0;
    }

    void upd(int tind, int l, int r, int ql, int qr, int x) {
        push(tind, l, r);
        if(ql <= l && r <= qr) {
            d[tind] += x;
            push(tind, l, r);
            return;
        }
        if(ql >= r || l >= qr) return;
        int m = (r + l) >> 1;
        upd(tind * 2 + 1, l, m, ql, qr, x);
        upd(tind * 2 + 2, m, r, ql, qr, x);
        tree[tind] = mrg(tree[tind * 2 + 1], tree[tind * 2 + 2]);
    }

    Node get(int tind, int l, int r, int ql, int qr) {
        push(tind, l, r);
        if(ql <= l && r <= qr) return tree[tind];
        if(ql >= r || l >= qr) return Node();
        int m = (r + l) >> 1;
        return mrg(get(tind * 2 + 1, l, m, ql, qr), get(tind * 2 + 2, m, r, ql, qr));
    }
};

signed main() {
#ifdef LOCAL
    freopen("inp.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    int h, w, q;
    cin >> h >> w >> q;
    vector<int> a(h), b(w);
    for(int i = 0; i < h; ++i) cin >> a[i];
    for(int i = 0; i < w; ++i) cin >> b[i];
    SegTree A, B;
    A.build(0, 0, h, a);
    B.build(0, 0, w, b);

    while(q--) {
        int t;
        cin >> t;
        if(t == 1) {
            int l, r, v;
            cin >> l >> r >> v;
            A.upd(0, 0, h, l - 1, r, v);
        } else if(t == 2) {
            int l, r, v;
            cin >> l >> r >> v;
            B.upd(0, 0, w, l - 1, r, v);
        } else if(t == 3) {
            int l1, r1, l2, r2;
            cin >> l1 >> r1 >> l2 >> r2;
            Node t1 = A.get(0, 0, h, l1 - 1, r1);
            Node t2 = B.get(0, 0, w, l2 - 1, r2);
            long long v1 = 1LL * t1.mx * t2.mn;
            long long v2 = 1LL * t1.mn * t2.mx;
            long long v3 = 1LL * t1.mn * t2.mn;
            long long v4 = 1LL * t1.mx * t2.mx;
            long long ans = min(min(v1, v2), min(v3, v4));
            long long cnt = 0;
            if(ans == 0) {
                int c10 = 0, c20 = 0;
                if(t1.mn == 0) c10 = t1.cmn;
                if(t1.mx == 0) c10 = t1.cmx;
                if(t2.mn == 0) c20 = t2.cmn;
                if(t2.mx == 0) c20 = t2.cmx;
                cnt += 1LL * c10 * (r2 - l2 + 1);
                cnt += 1LL * c20 * (r1 - l1 + 1);
                cnt -= 1LL * c10 * c20;
            } else {
                if(v1 == ans) cnt += 1LL * t1.cmx * t2.cmn;
                if(v2 == ans) cnt += 1LL * t1.cmn * t2.cmx;
                if(v3 == ans) cnt += 1LL * t1.cmn * t2.cmn;
                if(v4 == ans) cnt += 1LL * t1.cmx * t2.cmx;
                if(t1.mx == t1.mn) cnt /= 2;
                if(t2.mn == t2.mx) cnt /= 2;
            }
            cout << ans << " " << cnt << "\n";
        } else if(t == 4) {
            int l1, r1, l2, r2;
            cin >> l1 >> r1 >> l2 >> r2;
            Node t1 = A.get(0, 0, h, l1 - 1, r1);
            Node t2 = B.get(0, 0, w, l2 - 1, r2);
            long long v1 = 1LL * t1.mx * t2.mn;
            long long v2 = 1LL * t1.mn * t2.mx;
            long long v3 = 1LL * t1.mn * t2.mn;
            long long v4 = 1LL * t1.mx * t2.mx;
            long long ans = max(max(v1, v2), max(v3, v4));
            long long cnt = 0;
            if(ans == 0) {
                int c10 = 0, c20 = 0;
                if(t1.mn == 0) c10 = t1.cmn;
                if(t1.mx == 0) c10 = t1.cmx;
                if(t2.mn == 0) c20 = t2.cmn;
                if(t2.mx == 0) c20 = t2.cmx;
                cnt += 1LL * c10 * (r2 - l2 + 1);
                cnt += 1LL * c20 * (r1 - l1 + 1);
                cnt -= 1LL * c10 * c20;
            } else {
                if(v1 == ans) cnt += 1LL * t1.cmx * t2.cmn;
                if(v2 == ans) cnt += 1LL * t1.cmn * t2.cmx;
                if(v3 == ans) cnt += 1LL * t1.cmn * t2.cmn;
                if(v4 == ans) cnt += 1LL * t1.cmx * t2.cmx;
                if(t1.mx == t1.mn) cnt /= 2;
                if(t2.mn == t2.mx) cnt /= 2;
            }
            cout << ans << " " << cnt << "\n";
        }
    }
    return 0;
}
accuracy: 1
time_ms: 180
memory_kb: 19484
final_rank: 1

code_snippet: #include<iostream>
#include<vector>

using namespace std;
const int N = 1e5 + 10;
const int INF = 1e9 + 7;

struct Node {
    int mn, mx, cmn, cmx;
    Node() {
        mn = INF, mx = -INF, cmn = 0, cmx = 0;
    }
    Node(int x) {
        mn = mx = x, cmn = cmx = 1;
    }
};

Node mrg(Node t1, Node t2) {
    Node ans;

    if(t1.mn < t2.mn) ans.mn = t1.mn, ans.cmn = t1.cmn;
    else if(t1.mn == t2.mn) ans.mn = t1.mn, ans.cmn = t1.cmn + t2.cmn;
    else ans.mn = t2.mn, ans.cmn = t2.cmn;

    if(t1.mx > t2.mx) ans.mx = t1.mx, ans.cmx = t1.cmx;
    else if(t1.mx == t2.mx) ans.mx = t1.mx, ans.cmx = t1.cmx + t2.cmx;
    else ans.mx = t2.mx, ans.cmx = t2.cmx;

    return ans;
}

struct SegTree {
    vector<Node> tree;
    vector<int> d;

    SegTree() {
        tree.resize(N * 4, Node());
        d.resize(N * 4, 0);
    }

    void build(int tind, int l, int r, vector<int> &a) {
        if(r - l == 1) {
            tree[tind] = Node(a[l]);
            return;
        }
        int m = (r + l) >> 1;
        build(tind * 2 + 1, l, m, a);
        build(tind * 2 + 2, m, r, a);
        tree[tind] = mrg(tree[tind * 2 + 1], tree[tind * 2 + 2]);
    }

    void push(int tind, int l, int r) {
        if(d[tind] == 0) return;
        tree[tind].mn += d[tind], tree[tind].mx += d[tind];
        if(r - l > 1) {
            d[tind * 2 + 1] += d[tind];
            d[tind * 2 + 2] += d[tind];
        }
        d[tind] = 0;
    }

    void upd(int tind, int l, int r, int ql, int qr, int x) {
        push(tind, l, r);
        if(ql <= l && r <= qr) {
            d[tind] += x;
            push(tind, l, r);
            return;
        }
        if(ql >= r || l >= qr) return;
        int m = (r + l) >> 1;
        upd(tind * 2 + 1, l, m, ql, qr, x);
        upd(tind * 2 + 2, m, r, ql, qr, x);
        tree[tind] = mrg(tree[tind * 2 + 1], tree[tind * 2 + 2]);
    }

    Node get(int tind, int l, int r, int ql, int qr) {
        push(tind, l, r);
        if(ql <= l && r <= qr) return tree[tind];
        if(ql >= r || l >= qr) return Node();
        int m = (r + l) >> 1;
        return mrg(get(tind * 2 + 1, l, m, ql, qr), get(tind * 2 + 2, m, r, ql, qr));
    }
};

signed main() {
#ifdef LOCAL
    freopen("inp.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    int h, w, q;
    cin >> h >> w >> q;
    vector<int> a(h), b(w);
    for(int i = 0; i < h; ++i) cin >> a[i];
    for(int i = 0; i < w; ++i) cin >> b[i];
    SegTree A, B;
    A.build(0, 0, h, a);
    B.build(0, 0, w, b);

    while(q--) {
        int t;
        cin >> t;
        if(t == 1) {
            int l, r, v;
            cin >> l >> r >> v;
            A.upd(0, 0, h, l - 1, r, v);
        } else if(t == 2) {
            int l, r, v;
            cin >> l >> r >> v;
            B.upd(0, 0, w, l - 1, r, v);
        } else if(t == 3) {
            int l1, r1, l2, r2;
            cin >> l1 >> r1 >> l2 >> r2;
            Node t1 = A.get(0, 0, h, l1 - 1, r1);
            Node t2 = B.get(0, 0, w, l2 - 1, r2);
            long long v1 = 1LL * t1.mx * t2.mn;
            long long v2 = 1LL * t1.mn * t2.mx;
            long long v3 = 1LL * t1.mn * t2.mn;
            long long v4 = 1LL * t1.mx * t2.mx;
            long long ans = min(min(v1, v2), min(v3, v4));
            long long cnt = 0;
            if(ans == 0) {
                if(t1.mn == 0) cnt += 1LL * t1.cmn * (r2 - l2 + 1);
                if(t1.mx == 0) cnt += 1LL * t1.cmx * (r2 - l2 + 1);
                if(t2.mn == 0) {
                    cnt += 1LL * t2.cmn * (r1 - l1 + 1);
                    cnt -= (t1.mn == 0) + (t1.mx == 0);
                }
                if(t2.mx == 0) {
                    cnt += 1LL * t2.cmx * (r1 - l1 + 1);
                    cnt -= (t1.mn == 0) + (t1.mx == 0);
                }
            } else {
                if(v1 == ans) cnt += 1LL * t1.cmx * t2.cmn;
                if(v2 == ans) cnt += 1LL * t1.cmn * t2.cmx;
                if(v3 == ans) cnt += 1LL * t1.cmn * t2.cmn;
                if(v4 == ans) cnt += 1LL * t1.cmx * t2.cmx;
            }
            if(t1.mx == t1.mn) cnt /= 2;
            if(t2.mn == t2.mx) cnt /= 2;
            cout << ans << " " << cnt << '\n';
        } else if(t == 4) {
            int l1, r1, l2, r2;
            cin >> l1 >> r1 >> l2 >> r2;
            Node t1 = A.get(0, 0, h, l1 - 1, r1);
            Node t2 = B.get(0, 0, w, l2 - 1, r2);
            long long v1 = 1LL * t1.mx * t2.mn;
            long long v2 = 1LL * t1.mn * t2.mx;
            long long v3 = 1LL * t1.mn * t2.mn;
            long long v4 = 1LL * t1.mx * t2.mx;
            long long ans = max(max(v1, v2), max(v3, v4));
            long long cnt = 0;
            if(ans == 0) {
                if(t1.mn == 0) cnt += 1LL * t1.cmn * (r2 - l2 + 1);
                if(t1.mx == 0) cnt += 1LL * t1.cmx * (r2 - l2 + 1);
                if(t2.mn == 0) {
                    cnt += 1LL * t2.cmn * (r1 - l1 + 1);
                    cnt -= (t1.mn == 0) + (t1.mx == 0);
                }
                if(t2.mx == 0) {
                    cnt += 1LL * t2.cmx * (r1 - l1 + 1);
                    cnt -= (t1.mn == 0) + (t1.mx == 0);
                }
            } else {
                if(v1 == ans) cnt += 1LL * t1.cmx * t2.cmn;
                if(v2 == ans) cnt += 1LL * t1.cmn * t2.cmx;
                if(v3 == ans) cnt += 1LL * t1.cmn * t2.cmn;
                if(v4 == ans) cnt += 1LL * t1.cmx * t2.cmx;
            }
            if(t1.mx == t1.mn) cnt /= 2;
            if(t2.mn == t2.mx) cnt /= 2;
            cout << ans << " " << cnt << '\n';
        }
    }
    return 0;
}
accuracy: 0.735632183908046
time_ms: 180
memory_kb: 19480
final_rank: 8

code_snippet: #include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
#include<assert.h>
#include<numeric>
using namespace std;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
typedef long long ll;
typedef pair<int,int> pint;
typedef pair<ll,int> pli;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;

template<typename T>
struct LazySegmentTree{
private:
    int n;
    vector<T> node;
    vector<int> lazy;
    T E0;
    int E1=0;

    inline void updatef(int& lazy,int& value){
        //lazy += value;
        lazy += value;
        //lazy = max(lazy, value);
        //lazy = min(lazy, value);
    }
    inline void calculatef(T& node,int& lazy,int len){
        //node += lazy * len;
        // node += lazy ;
        node.first += lazy ;
    }
    inline T queryf(T& x,T& y){
        //return x + y;
        //return x * y;
        //return max(x, y);
        if(x.first<y.first)return x;
        else if(x.first>y.first)return y;
        else return {x.first, x.second+y.second};
    }
public:
    LazySegmentTree(int sz,T nodeE,int lazyE = 0):E0(nodeE), E1(lazyE){
        n=1;
        while(n<sz)n<<=1;
        node.resize(2*n-1,E0);
        lazy.resize(2*n-1,E1);
    }

    LazySegmentTree(vector<T>& v,T E0,int E1=0 ):E0(E0),E1(E1){
        n=1;
        int sz=v.size();
        while(n<sz)n<<=1;
        node.resize(2*n-1,E0);
        lazy.resize(2*n-1,E1);
        rep(i,sz)node[i+n-1] = v[i];
        for(int i=n-2; i>=0; --i){
            node[i] = queryf(node[2*i+1],node[2*i+2]);
        }
    }

    void eval(int k,int l,int r){
        if(lazy[k]==E1)return ;
        calculatef(node[k], lazy[k], r-l);
        if(r-l>1){
            updatef(lazy[2*k+1], lazy[k]);
            updatef(lazy[2*k+2], lazy[k]);
        }
        lazy[k]=E1;
    }

    void update(int a, int b, int x,int k=0,int l=0,int r=-1){
        if(r<0)r=n;
        eval(k,l,r);
        if(r<=a||b<=l)return;
        if(a<=l&&r<=b){
            updatef(lazy[k], x);
            eval(k,l,r);
        }
        else {
            update(a,b,x,2*k+1,l,(l+r)/2);
            update(a,b,x,2*k+2,(l+r)/2,r);
            node[k]=queryf(node[2*k+1], node[2*k+2]);
        }
    }

    T query(int a,int b,int k=0,int l=0,int r=-1){
        if(r<0)r=n;
        eval(k,l,r);
        if(r<=a||b<=l)return E0;
        if(a<=l&&r<=b)return node[k];
        T xl=query(a,b,2*k+1,l,(l+r)/2);
        T xr=query(a,b,2*k+2,(l+r)/2,r);
        return queryf(xl, xr);
    }
};

pair<ll,ll> fun(pair<ll,ll> p,pair<ll,ll>q){
    if(p.first<q.first)return p;
    if(p.first>q.first)return q;
    else return {p.first,p.second+q.second};
}
pair<ll,ll> mul(pair<ll,ll> p,pair<ll,ll>q){
    return {p.first*q.first, p.second*q.second};
}


int main(){
    int h,w,q;
    cin>>h>>w>>q;
    vector<pair<ll,ll>> h1(h),h2(h),w1(w),w2(w);
    rep(i,h){
        cin>>h1[i].first;
        h2[i].first=-h1[i].first;
        h1[i].second=h2[i].second=1;
    } 
    rep(i,w){
        cin>>w1[i].first;
        w2[i].first=-w1[i].first;
        w1[i].second=w2[i].second=1;
    } 
    pair<ll,ll> e={longinf,1};
    LazySegmentTree<pair<ll,ll>> hmin(h1,e),hmax(h2,e),wmin(w1,e),wmax(w2,e);
    while(q--){
        int type;
        cin>>type;
        if(type==1){
            int a,b,c;
            cin>>a>>b>>c;
            hmin.update(a-1,b,c);
            hmax.update(a-1,b,-c);
        }
        else if(type==2){
            int a,b,c;
            cin>>a>>b>>c;
            wmin.update(a-1,b,c);
            wmax.update(a-1,b,-c);
        }
        else if(type==3){
            int a,b,c,d;
            cin>>a>>b>>c>>d;
            auto Hmin=hmin.query(a-1, b);
            auto Hmax=hmax.query(a-1, b);
            auto Wmin=wmin.query(c-1, d);
            auto Wmax=wmax.query(c-1, d);
            Hmax.first*=-1;
            Wmax.first*=-1;
            if(Hmin.second==b-a+1)Hmax={Hmin.first,0};
            if(Wmin.second==d-c+1)Wmax={Wmin.first,0};
            pair<ll,ll> ans={longinf,1};
            ans=fun(ans,mul(Hmin,Wmin));
            ans=fun(ans,mul(Hmax,Wmin));
            ans=fun(ans,mul(Hmin,Wmax));
            ans=fun(ans,mul(Hmax,Wmax));
            if(ans.first==0){
                ll cnth=0,cntw=0;
                if(Hmax.first==0)cnth=Hmax.second;
                if(Hmin.first==0)cnth=Hmin.second;
                if(Wmax.first==0)cntw=Wmax.second;
                if(Wmin.first==0)cntw=Wmin.second;
                ans.second=(ll)(d-c+1)*(b-a+1)-(b-a+1-cnth)*(d-c+1-cntw);
            }
            cout<<ans.first<<" "<<ans.second<<endl;
        }
        else if(type==4){
            int a,b,c,d;
            cin>>a>>b>>c>>d;
            auto Hmin=hmin.query(a-1, b);
            auto Hmax=hmax.query(a-1, b);
            auto Wmin=wmin.query(c-1, d);
            auto Wmax=wmax.query(c-1, d);
            Hmax.first*=-1;
            Wmin.first*=-1;
            if(Hmin.second==b-a+1)Hmax={Hmax.first,0};
            if(Wmin.second==d-c+1)Wmax={Wmax.first,0};
            pair<ll,ll> ans={longinf,1};
            ans=fun(ans,mul(Hmin,Wmin));
            ans=fun(ans,mul(Hmax,Wmin));
            ans=fun(ans,mul(Hmin,Wmax));
            ans=fun(ans,mul(Hmax,Wmax));
            if(ans.first==0){
                ll cnth=0,cntw=0;
                if(Hmax.first==0)cnth=Hmax.second;
                if(Hmin.first==0)cnth=Hmin.second;
                if(Wmax.first==0)cntw=Wmax.second;
                if(Wmin.first==0)cntw=Wmin.second;
                ans.second=(ll)(d-c+1)*(b-a+1)-(b-a+1-cnth)*(d-c+1-cntw);
            }
            cout<<-ans.first<<" "<<ans.second<<endl;
        }
    } 
    return 0;
}
accuracy: 1
time_ms: 310
memory_kb: 28888
final_rank: 7

code_snippet: #include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}

template <typename T,typename E>
struct SegmentTree{
  using F = function<T(T,T)>;
  using G = function<T(T,E)>;
  using H = function<E(E,E)>;
  int n,height;
  F f;
  G g;
  H h;
  T ti;
  E ei;
  vector<T> dat;
  vector<E> laz;
  SegmentTree(F f,G g,H h,T ti,E ei):
    f(f),g(g),h(h),ti(ti),ei(ei){}
  
  void init(int n_){
    n=1;height=0;
    while(n<n_) n<<=1,height++;
    dat.assign(2*n,ti);
    laz.assign(2*n,ei);
  }
  void build(const vector<T> &v){
    int n_=v.size();
    init(n_);
    for(int i=0;i<n_;i++) dat[n+i]=v[i];
    for(int i=n-1;i;i--)
      dat[i]=f(dat[(i<<1)|0],dat[(i<<1)|1]);
  }
  inline T reflect(int k){
    return laz[k]==ei?dat[k]:g(dat[k],laz[k]);
  }
  inline void eval(int k){
    if(laz[k]==ei) return;
    laz[(k<<1)|0]=h(laz[(k<<1)|0],laz[k]);
    laz[(k<<1)|1]=h(laz[(k<<1)|1],laz[k]);
    dat[k]=reflect(k);
    laz[k]=ei;
  }
  inline void thrust(int k){
    for(int i=height;i;i--) eval(k>>i);
  }
  inline void recalc(int k){    
    while(k>>=1)
      dat[k]=f(reflect((k<<1)|0),reflect((k<<1)|1));
  }
  void update(int a,int b,E x){
    thrust(a+=n);
    thrust(b+=n-1);
    for(int l=a,r=b+1;l<r;l>>=1,r>>=1){
      if(l&1) laz[l]=h(laz[l],x),l++;
      if(r&1) --r,laz[r]=h(laz[r],x);
    }
    recalc(a);
    recalc(b);
  }
  void set_val(int a,T x){
    thrust(a+=n);
    dat[a]=x;laz[a]=ei;
    recalc(a);
  }
  T query(int a,int b){
    thrust(a+=n);
    thrust(b+=n-1);
    T vl=ti,vr=ti;
    for(int l=a,r=b+1;l<r;l>>=1,r>>=1) {
      if(l&1) vl=f(vl,reflect(l++));
      if(r&1) vr=f(reflect(--r),vr);
    }
    return f(vl,vr);
  }
};

//INSERT ABOVE HERE
signed main(){
  struct T{
    Int w,x,y,z;
    T(Int w,Int x,Int y,Int z):w(w),x(x),y(y),z(z){}
  };
  
  auto f=[](T a,T b){
           Int cw=min(a.w,b.w);
           Int cx=(a.w==b.w?a.x+b.x:(a.w<b.w?a.x:b.x));
           Int cy=max(a.y,b.y);
           Int cz=(a.y==b.y?a.z+b.z:(a.y>b.y?a.z:b.z));
           return T(cw,cx,cy,cz);
         };
  auto g=[](T a,Int b){
           return T(a.w+b,a.x,a.y+b,a.z);
         };
  auto h=[](Int a,Int b){return a+b;};

  Int H,W,Q;
  scanf("%lld %lld %lld",&H,&W,&Q);
  vector<T> A,B;
  for(Int i=0;i<H;i++){
    Int v;
    scanf("%lld",&v);
    A.emplace_back(v,1,v,1);
  }
  for(Int i=0;i<W;i++){
    Int v;
    scanf("%lld",&v);
    B.emplace_back(v,1,v,1);
  }
  
  const Int INF = 1e17;
  T ti(INF,0,-INF,0);
  SegmentTree<T, Int> segY(f,g,h,ti,0);
  SegmentTree<T, Int> segX(f,g,h,ti,0);
  segY.build(A);
  segX.build(B);

  auto calc=[](Int t,T a,T b,Int p,Int q){
              Int res=t==3?
                min({a.w*b.w,a.w*b.y,a.y*b.w,a.y*b.y}):
                max({a.w*b.w,a.w*b.y,a.y*b.w,a.y*b.y});
              Int cnt=0;
              Int n=p-(!a.w?a.x:!a.y?a.z:0ll);
              Int m=q-(!b.w?b.x:!b.y?b.z:0ll);
              if(res==0) cnt=p*q-n*m;
              else{
                if(a.w==a.y) a.z=0;
                if(b.w==b.y) b.z=0;
                if(res==a.w*b.w) cnt+=a.x*b.x;
                if(res==a.w*b.y) cnt+=a.x*b.z;
                if(res==a.y*b.w) cnt+=a.z*b.x;
                if(res==a.y*b.y) cnt+=a.z*b.z;
              }
              printf("%lld %lld\n",res,cnt);
            };
  
  for(Int i=0;i<Q;i++){
    Int t;
    scanf("%lld",&t);
    if(t==1){
      Int a,b,v;
      scanf("%lld %lld %lld",&a,&b,&v);
      segY.update(--a,b,v);
    }
    if(t==2){
      Int c,d,v;
      scanf("%lld %lld %lld",&c,&d,&v);
      segX.update(--c,d,v);
    }
    if(t==3||t==4){
      Int a,b,c,d;
      scanf("%lld %lld %lld %lld",&a,&b,&c,&d);
      T y=segY.query(--a,b);
      T x=segX.query(--c,d);
      calc(t,y,x,b-a,d-c);
    }
  }
  return 0;
}
accuracy: 1
time_ms: 160
memory_kb: 28896
final_rank: 3

code_snippet: #include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}

template <typename T,typename E>
struct SegmentTree{
  using F = function<T(T,T)>;
  using G = function<T(T,E)>;
  using H = function<E(E,E)>;
  int n,height;
  F f;
  G g;
  H h;
  T ti;
  E ei;
  vector<T> dat;
  vector<E> laz;
  SegmentTree(int n_,F f,G g,H h,T ti,E ei):
    f(f),g(g),h(h),ti(ti),ei(ei){init(n_);}
  void init(int n_){
    n=1;height=0;
    while(n<n_) n<<=1,height++;
    dat.assign(2*n,ti);
    laz.assign(2*n,ei);
  }
  void build(int n_, vector<T> v){
    for(int i=0;i<n_;i++) dat[n+i]=v[i];
    for(int i=n-1;i;i--)
      dat[i]=f(dat[(i<<1)|0],dat[(i<<1)|1]);
  }
  inline T reflect(int k){
    return g(dat[k],laz[k]);
  }
  inline void eval(int k){
    if(laz[k]==ei) return;
    laz[(k<<1)|0]=h(laz[(k<<1)|0],laz[k]);
    laz[(k<<1)|1]=h(laz[(k<<1)|1],laz[k]);
    dat[k]=reflect(k);
    laz[k]=ei;
  }
  inline void thrust(int k){
    for(int i=height;i;i--) eval(k>>i);
  }
  inline void recalc(int k){    
    while(k>>=1)
      dat[k]=f(reflect((k<<1)|0),reflect((k<<1)|1));
  }
  void update(int a,int b,E x){
    thrust(a+=n);
    thrust(b+=n-1);
    for(int l=a,r=b+1;l<r;l>>=1,r>>=1){
      if(l&1) laz[l]=h(laz[l],x),l++;
      if(r&1) --r,laz[r]=h(laz[r],x);
    }
    recalc(a);
    recalc(b);
  }
  void set_val(int a,T x){
    thrust(a+=n);
    dat[a]=x;laz[a]=ei;
    recalc(a);
  }
  T query(int a,int b){
    thrust(a+=n);
    thrust(b+=n-1);
    T vl=ti,vr=ti;
    for(int l=a,r=b+1;l<r;l>>=1,r>>=1) {
      if(l&1) vl=f(vl,reflect(l++));
      if(r&1) vr=f(reflect(--r),vr);
    }
    return f(vl,vr);
  }
};

//INSERT ABOVE HERE
signed main(){
  using T = tuple<Int, Int, Int, Int>;
  
  auto f=[](T a,T b){
           Int aw,ax,ay,az;
           tie(aw,ax,ay,az)=a;
           Int bw,bx,by,bz;
           tie(bw,bx,by,bz)=b;
           Int cw=min(aw,bw);
           Int cx=(aw==bw?ax+bx:(aw<bw?ax:bx));
           Int cy=max(ay,by);
           Int cz=(ay==by?az+bz:(ay>by?az:bz));
           return T(cw,cx,cy,cz);
         };
  auto g=[](T a,Int b){
           Int aw,ax,ay,az;
           tie(aw,ax,ay,az)=a;
           return T(aw+b,ax,ay+b,az);
         };
  auto h=[](Int a,Int b){return a+b;};

  Int H,W,Q;
  scanf("%lld %lld %lld",&H,&W,&Q);
  vector<T> A,B;
  for(Int i=0;i<H;i++){
    Int v;
    scanf("%lld",&v);
    A.emplace_back(v,1,v,1);
  }
  for(Int i=0;i<W;i++){
    Int v;
    scanf("%lld",&v);
    B.emplace_back(v,1,v,1);
  }
  
  const Int INF = 1e17;
  T ti(INF,0,-INF,0);
  SegmentTree<T, Int> segY(H,f,g,h,ti,0);
  SegmentTree<T, Int> segX(W,f,g,h,ti,0);
  segY.build(H,A);
  segX.build(W,B);

  auto calc=[](Int t,T a,T b,Int p,Int q){
              Int aw,ax,ay,az;
              tie(aw,ax,ay,az)=a;
              Int bw,bx,by,bz;
              tie(bw,bx,by,bz)=b;
              Int res=t==3?
                min({aw*bw,aw*by,ay*bw,ay*by}):
                max({aw*bw,aw*by,ay*bw,ay*by});
              Int cnt=0;
              Int n=p-(!aw?ax:!ay?az:0ll);
              Int m=q-(!bw?bx:!by?bz:0ll);
              if(res==0) cnt=p*q-n*m;
              else{
                if(aw==ay) az=0;
                if(bw==by) bz=0;
                if(res==aw*bw) cnt+=ax*bx;
                if(res==aw*by) cnt+=ax*bz;
                if(res==ay*bw) cnt+=az*bx;
                if(res==ay*by) cnt+=az*bz;
              }
              printf("%lld %lld\n",res,cnt);
            };
  
  for(Int i=0;i<Q;i++){
    Int t;
    scanf("%lld",&t);
    if(t==1){
      Int a,b,v;
      scanf("%lld %lld %lld",&a,&b,&v);
      segY.update(--a,b,v);
    }
    if(t==2){
      Int c,d,v;
      scanf("%lld %lld %lld",&c,&d,&v);
      segX.update(--c,d,v);
    }
    if(t==3||t==4){
      Int a,b,c,d;
      scanf("%lld %lld %lld %lld",&a,&b,&c,&d);
      T y=segY.query(--a,b);
      T x=segX.query(--c,d);
      calc(t,y,x,b-a,d-c);
    }
  }
  return 0;
}
accuracy: 1
time_ms: 160
memory_kb: 31888
final_rank: 4

code_snippet: #include<bits/stdc++.h>
using namespace std;
using Int = long long;

template <typename T,typename E>
struct SegmentTree{
  typedef function<T(T,T)> F;
  typedef function<T(T,E)> G;
  typedef function<E(E,E)> H;
  typedef function<E(E,Int)> P;
  Int n;
  F f;
  G g;
  H h;
  T d1;
  E d0;
  P p;
  vector<T> dat;
  vector<E> laz;
  SegmentTree(Int n_,F f,G g,H h,T d1,E d0,
	      vector<T> v=vector<T>(),
	      P p=[](E a,Int b){++b;return a;}):
    f(f),g(g),h(h),d1(d1),d0(d0),p(p){
    
    init(n_);
    if(n_==(Int)v.size()) build(n_,v);
  }
  void init(Int n_){
    n=1;
    while(n<n_) n*=2;
    dat.clear();
    dat.resize(2*n-1,d1);
    laz.clear();
    laz.resize(2*n-1,d0);
  }
  void build(Int n_, vector<T> v){
    for(Int i=0;i<n_;i++) dat[i+n-1]=v[i];
    for(Int i=n-2;i>=0;i--)
      dat[i]=f(dat[i*2+1],dat[i*2+2]);
  }
  inline void eval(Int len,Int k){
    if(laz[k]==d0) return;
    if(k*2+1<n*2-1){
      laz[k*2+1]=h(laz[k*2+1],laz[k]);
      laz[k*2+2]=h(laz[k*2+2],laz[k]);
    }
    dat[k]=g(dat[k],p(laz[k],len));
    laz[k]=d0;
  }
  T update(Int a,Int b,E x,Int k,Int l,Int r){
    eval(r-l,k);
    if(r<=a||b<=l) return dat[k];
    if(a<=l&&r<=b){
      laz[k]=h(laz[k],x);
      return g(dat[k],p(laz[k],r-l));
    }
    return dat[k]=f(update(a,b,x,k*2+1,l,(l+r)/2),
		    update(a,b,x,k*2+2,(l+r)/2,r));
  }
  T update(Int a,Int b,E x){
    return update(a,b,x,0,0,n);
  }
  T query(Int a,Int b,Int k,Int l,Int r){
    eval(r-l,k);
    if(r<=a||b<=l) return d1;
    if(a<=l&&r<=b) return dat[k];
    T vl=query(a,b,k*2+1,l,(l+r)/2);
    T vr=query(a,b,k*2+2,(l+r)/2,r);
    return f(vl,vr);
  }
  T query(Int a,Int b){
    return query(a,b,0,0,n);
  }
  void update(Int k,T x){
    query(k,k+1);//evaluate
    k+=n-1;
    dat[k]=x;
    while(k){
      k=(k-1)/2;
      dat[k]=f(dat[k*2+1],dat[k*2+2]);
    }
  }
};

struct FastIO{
  FastIO(){
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
}fastio_beet;

//INSERT ABOVE HERE
signed main(){
  using T = tuple<Int, Int, Int, Int>;
  
  SegmentTree<T, Int>::F f=[](T a,T b){
    Int aw,ax,ay,az;
    tie(aw,ax,ay,az)=a;
    Int bw,bx,by,bz;
    tie(bw,bx,by,bz)=b;
    Int cw=min(aw,bw);
    Int cx=(aw==bw?ax+bx:(aw<bw?ax:bx));
    Int cy=max(ay,by);
    Int cz=(ay==by?az+bz:(ay>by?az:bz));
    return T(cw,cx,cy,cz);
  };
 
  SegmentTree<T, Int>::G g=[](T a,Int b){
    Int aw,ax,ay,az;
    tie(aw,ax,ay,az)=a;
    return T(aw+b,ax,ay+b,az);
  };

  SegmentTree<T, Int>::H h=[](Int a,Int b){
    return a+b;
  };

  Int H,W,Q;
  cin>>H>>W>>Q;
  vector<T> A,B;
  for(Int i=0;i<H;i++){
    Int v;
    cin>>v;
    A.emplace_back(v,1,v,1);
  }
  for(Int i=0;i<W;i++){
    Int v;
    cin>>v;
    B.emplace_back(v,1,v,1);
  }
  
  const Int INF = 1e17;
  T d1(INF,0,-INF,0);
  SegmentTree<T, Int> segY(H,f,g,h,d1,0,A);
  SegmentTree<T, Int> segX(W,f,g,h,d1,0,B);

  auto calc=[](Int t,T a,T b,Int p,Int q){
    Int aw,ax,ay,az;
    tie(aw,ax,ay,az)=a;
    Int bw,bx,by,bz;
    tie(bw,bx,by,bz)=b;
    Int res=t==3?
    min({aw*bw,aw*by,ay*bw,ay*by}):
    max({aw*bw,aw*by,ay*bw,ay*by});
    Int cnt=0;
    Int n=p-(!aw?ax:!ay?az:0ll);
    Int m=q-(!bw?bx:!by?bz:0ll);
    if(res==0) cnt=p*q-n*m;
    else{
      if(aw==ay) az=0;
      if(bw==by) bz=0;
      if(res==aw*bw) cnt+=ax*bx;
      if(res==aw*by) cnt+=ax*bz;
      if(res==ay*bw) cnt+=az*bx;
      if(res==ay*by) cnt+=az*bz;
    }
    
    cout<<res<<" "<<cnt<<endl;
  };
  
  for(Int i=0;i<Q;i++){
    Int t;
    cin>>t;
    if(t==1){
      Int a,b,v;
      cin>>a>>b>>v;
      segY.update(--a,b,v);
    }
    if(t==2){
      Int c,d,v;
      cin>>c>>d>>v;
      segX.update(--c,d,v);
    }
    if(t==3||t==4){
      Int a,b,c,d;
      cin>>a>>b>>c>>d;
      T y=segY.query(--a,b);
      T x=segX.query(--c,d);
      calc(t,y,x,b-a,d-c);
    }
  }
  
  return 0;
}
accuracy: 1
time_ms: 250
memory_kb: 34980
final_rank: 6

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld =long double;
const ld eps = 1e-9;

#define Seg_Max_N (1<<18) 

struct aa {
	long long int amin;
	long long int min_num;

	long long int amax;
	long long int max_num;
};

typedef aa Value1;
typedef long long int Value2;
const Value1 Zero1 = aa{ 0,1,0,1 };
const Value2 Zero2 =0;

struct Node {
	Value1 sum;//更新された値. この値を参照する時は評価が完全に完了しているようにする.
	Value2 lazy;	//遅延されている値を保存している
	Node() :sum(Zero1) {
		lazy = Zero2;
	}
};
struct lazy_segtree {
	int N;
	vector<Node>dat;
	lazy_segtree(int n) :N(1) {
		while (N < n) N *= 2;
		dat.resize(2 * N);
	}

	Value2 lazy_connect(const Value2 l, const Value2 r) {
		return l+r;
	}

	void lazy_func(const int k, const int a, const int b) {
		
		dat[k].sum.amin += dat[k].lazy;
		dat[k].sum.amax+=dat[k].lazy;
		
	}

	Value1 connect(const Value1 l, const Value1 r) {
		aa naa;
		if (l.amin == r.amin) {
			naa.amin = l.amin;
			naa.min_num = l.min_num + r.min_num;
		}
		else if (l.amin > r.amin) {
			naa.amin = r.amin;
			naa.min_num = r.min_num;
		}
		else {
			naa.amin = l.amin;
			naa.min_num = l.min_num;
		}

		if (l.amax == r.amax) {
			naa.amax = l.amax;
			naa.max_num = l.max_num + r.max_num;
		}
		else if (l.amax < r.amax) {
			naa.amax = r.amax;
			naa.max_num = r.max_num;
		}
		else {
			naa.amax = l.amax;
			naa.max_num = l.max_num;
		}
		return naa;
	}

	// inlineつけないと大変なことになるよ!(遅い)
	inline void lazy_evaluate_node(int k, int a, int b) {
		lazy_func(k, a, b);
		if (k < N) { // 2*k(左の子番号) < 2*N (節点の数) のイメージで. 末端ノードじゃなきゃ伝搬するのと等価.
			dat[2 * k].lazy = lazy_connect(dat[2 * k].lazy, dat[k].lazy);	//次は君が伝搬してね☆って感じ.
			dat[2 * k + 1].lazy = lazy_connect(dat[2 * k + 1].lazy, dat[k].lazy);
		}
		dat[k].lazy = Zero2;
	}

	inline void update_node(int k) { // kの子が既に評価されていることが前提. 末端以外のときしか呼び出さないような位置に書くのでif文要らない.
		dat[k].sum = connect(dat[2 * k].sum, dat[2 * k + 1].sum);

	}

	// update(l,r,v) := [l,r)を更新する. 区間は0-indexed.
	void update(int l, int r, Value2 v, int k = 1, int a = 0, int b = -1) {
		if (b == -1)b = N;
		if (l < 0 || r < 0)assert(false);
		lazy_evaluate_node(k, a, b); 	// とりあえず辿ったノードは都合がいいので伝搬しとけ精神.

		if (b <= l || r <= a) //[a,b)と[l,r)が交差している場合
			return;
		if (l <= a && b <= r) { // [l,r)が[a,b)を完全に含んでいる場合
			dat[k].lazy = lazy_connect(dat[k].lazy, v);
			lazy_evaluate_node(k, a, b); //一回遅延評価しとかないと都合悪いので.
			return;
		}

		int m = (a + b) / 2;
		update(l, r, v, 2 * k, a, m);
		update(l, r, v, 2 * k + 1, m, b);
		update_node(k);
	}
	//get(l,r) := [l,r)に対するクエリの答えを得る. 区間は0-indexed.
	Value1 get(int l, int r, int k = 1, int a = 0, int b = -1) {
		if (b == -1)b = N;

		if (l < 0 || r<0)assert(false);
		lazy_evaluate_node(k, a, b); // とりあえず辿ったノードは都合がいいので伝搬しとけ精神.

		if (b <= l || r <= a) //[a,b)と[l,r)が交差している場合
			return aa{static_cast<long long int>(1e18),0,static_cast<long long int>(-1e18),0 };

		if (l <= a && b <= r) { // [l,r)が[a,b)を完全に含んでいる場合
			return dat[k].sum;
		}

		int m = (a + b) / 2;
		Value1 vl = get(l, r, 2 * k, a, m);
		Value1 vr = get(l, r, 2 * k + 1, m, b);
		update_node(k);
		return connect(vl, vr);
	}
};

int main()
{
	int H,W,Q;cin>>H>>W>>Q;
	vector<int>as(H),bs(W);
	for(int i=0;i<H;++i)cin>>as[i];
	for(int i=0;i<W;++i)cin>>bs[i];
	lazy_segtree aseg(H),bseg(W);
	for (int i = 0; i < H; ++i) {
		aseg.update(i,i+1, as[i]);
	}
	for (int i = 0; i < W; ++i) {
		bseg.update(i,i+1, bs[i]);
	}
	while (Q--) {
		int type;cin>>type;
		if (type == 1) {
			int a,b,x;cin>>a>>b>>x;a--;
			aseg.update(a,b,x);
		}
		else if (type == 2) {
			int a,b,x;cin>>a>>b>>x;a--;
			bseg.update(a,b,x);
		}
		else {
			int a,b,c,d;cin>>a>>b>>c>>d;
			a--;c--;
			auto a_aa=aseg.get(a,b);
			auto b_aa=bseg.get(c,d);

			map<long long int,long long int>mp;

			if (a_aa.amin != a_aa.amax) {
				if (b_aa.amin != b_aa.amax) {

					mp[a_aa.amin*b_aa.amin] += a_aa.min_num*b_aa.min_num;
					mp[a_aa.amax*b_aa.amin] += a_aa.max_num*b_aa.min_num;
					mp[a_aa.amin*b_aa.amax] += a_aa.min_num*b_aa.max_num;
					mp[a_aa.amax*b_aa.amax] += a_aa.max_num*b_aa.max_num;
				}
				else {

					mp[a_aa.amin*b_aa.amin] += a_aa.min_num*b_aa.min_num;
					mp[a_aa.amax*b_aa.amin] += a_aa.max_num*b_aa.min_num;
				}
			}
			else {
				if (b_aa.amin != b_aa.amax) {

					mp[a_aa.amin*b_aa.amin] += a_aa.min_num*b_aa.min_num;
					mp[a_aa.amin*b_aa.amax] += a_aa.min_num*b_aa.max_num;
				}
				else {
					mp[a_aa.amin*b_aa.amin] += a_aa.min_num*b_aa.min_num;
				}
			}

			auto it=mp.begin();
			auto jt=prev(mp.end());

			if (type == 3) {
				long long int ans_num,ans_cnt;
				if (it->first == 0) {
					if (a_aa.amin == 0 && b_aa.amin == 0) {
						ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
					}
					else if (a_aa.amin == 0) {
						ans_cnt=(d-c)*a_aa.min_num;
					}
					else if(b_aa.amin==0){
						ans_cnt=(b-a)*b_aa.min_num;
					}
					else {
						swap(a_aa.amin,a_aa.amax);
						swap(a_aa.min_num,a_aa.max_num);
						swap(b_aa.amin,b_aa.amax);
						swap(b_aa.min_num, b_aa.max_num);

						if (a_aa.amin == 0 && b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
						}
						else if (a_aa.amin == 0) {
							ans_cnt = (d - c)*a_aa.min_num;
						}
						else if (b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num;
						}
						else {
							assert(false);
						}
					}
				}
				else {
					ans_cnt=it->second;
				}
				cout<<it->first<<" "<<ans_cnt<<endl;
			}
			else {
				long long int ans_num, ans_cnt;
				swap(b_aa.amin,b_aa.amax);
				swap(b_aa.min_num,b_aa.max_num);
				if (jt->first == 0) {
					if (a_aa.amin == 0 && b_aa.amin == 0) {
						ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
					}
					else if (a_aa.amin == 0) {
						ans_cnt = (d - c)*a_aa.min_num;
					}
					else if (b_aa.amin == 0) {
						ans_cnt = (b - a)*b_aa.min_num;
					}
					else {
						swap(a_aa.amin, a_aa.amax);
						swap(a_aa.min_num, a_aa.max_num);
						swap(b_aa.amin, b_aa.amax);
						swap(b_aa.min_num, b_aa.max_num);

						if (a_aa.amin == 0 && b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
						}
						else if (a_aa.amin == 0) {
							ans_cnt = (d - c)*a_aa.min_num;
						}
						else if (b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num;
						}
						else {
							assert(false);
						}
					}
				}
				else {
					ans_cnt = jt->second;
				}
				cout << jt->first << " " << ans_cnt << endl;
			}
		}
	}
	return 0;
}
accuracy: 1
time_ms: 290
memory_kb: 23944
final_rank: 5

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld =long double;
const ld eps = 1e-9;

#define Seg_Max_N (1<<18) 

struct aa {
	long long int amin;
	long long int min_num;

	long long int amax;
	long long int max_num;
};

typedef aa Value1;
typedef long long int Value2;
const Value1 Zero1 = aa{ 0,1,0,1 };
const Value2 Zero2 =0;

struct Node {
	Value1 sum;//更新された値. この値を参照する時は評価が完全に完了しているようにする.
	Value2 lazy;	//遅延されている値を保存している
	Node() :sum(Zero1) {
		lazy = Zero2;
	}
};
struct lazy_segtree {
	int N;
	vector<Node>dat;
	lazy_segtree(int n) :N(1) {
		while (N < n) N *= 2;
		dat.resize(2 * N);
	}

	Value2 lazy_connect(const Value2 l, const Value2 r) {
		return l+r;
	}

	void lazy_func(const int k, const int a, const int b) {
		
		dat[k].sum.amin += dat[k].lazy;
		dat[k].sum.amax+=dat[k].lazy;
		
	}

	Value1 connect(const Value1 l, const Value1 r) {
		aa naa;
		if (l.amin == r.amin) {
			naa.amin = l.amin;
			naa.min_num = l.min_num + r.min_num;
		}
		else if (l.amin > r.amin) {
			naa.amin = r.amin;
			naa.min_num = r.min_num;
		}
		else {
			naa.amin = l.amin;
			naa.min_num = l.min_num;
		}

		if (l.amax == r.amax) {
			naa.amax = l.amax;
			naa.max_num = l.max_num + r.max_num;
		}
		else if (l.amax < r.amax) {
			naa.amax = r.amax;
			naa.max_num = r.max_num;
		}
		else {
			naa.amax = l.amax;
			naa.max_num = l.max_num;
		}
		return naa;
	}

	// inlineつけないと大変なことになるよ!(遅い)
	inline void lazy_evaluate_node(int k, int a, int b) {
		lazy_func(k, a, b);
		if (k < N) { // 2*k(左の子番号) < 2*N (節点の数) のイメージで. 末端ノードじゃなきゃ伝搬するのと等価.
			dat[2 * k].lazy = lazy_connect(dat[2 * k].lazy, dat[k].lazy);	//次は君が伝搬してね☆って感じ.
			dat[2 * k + 1].lazy = lazy_connect(dat[2 * k + 1].lazy, dat[k].lazy);
		}
		dat[k].lazy = Zero2;
	}

	inline void update_node(int k) { // kの子が既に評価されていることが前提. 末端以外のときしか呼び出さないような位置に書くのでif文要らない.
		dat[k].sum = connect(dat[2 * k].sum, dat[2 * k + 1].sum);

	}

	// update(l,r,v) := [l,r)を更新する. 区間は0-indexed.
	void update(int l, int r, Value2 v, int k = 1, int a = 0, int b = -1) {
		if (b == -1)b = N;
		if (l < 0 || r < 0)assert(false);
		lazy_evaluate_node(k, a, b); 	// とりあえず辿ったノードは都合がいいので伝搬しとけ精神.

		if (b <= l || r <= a) //[a,b)と[l,r)が交差している場合
			return;
		if (l <= a && b <= r) { // [l,r)が[a,b)を完全に含んでいる場合
			dat[k].lazy = lazy_connect(dat[k].lazy, v);
			lazy_evaluate_node(k, a, b); //一回遅延評価しとかないと都合悪いので.
			return;
		}

		int m = (a + b) / 2;
		update(l, r, v, 2 * k, a, m);
		update(l, r, v, 2 * k + 1, m, b);
		update_node(k);
	}
	//get(l,r) := [l,r)に対するクエリの答えを得る. 区間は0-indexed.
	Value1 get(int l, int r, int k = 1, int a = 0, int b = -1) {
		if (b == -1)b = N;

		if (l < 0 || r<0)assert(false);
		lazy_evaluate_node(k, a, b); // とりあえず辿ったノードは都合がいいので伝搬しとけ精神.

		if (b <= l || r <= a) //[a,b)と[l,r)が交差している場合
			return aa{static_cast<long long int>(1e18),0,static_cast<long long int>(-1e18),0 };

		if (l <= a && b <= r) { // [l,r)が[a,b)を完全に含んでいる場合
			return dat[k].sum;
		}

		int m = (a + b) / 2;
		Value1 vl = get(l, r, 2 * k, a, m);
		Value1 vr = get(l, r, 2 * k + 1, m, b);
		update_node(k);
		return connect(vl, vr);
	}
};

int main()
{
	int H,W,Q;cin>>H>>W>>Q;
	vector<int>as(H),bs(W);
	for(int i=0;i<H;++i)cin>>as[i];
	for(int i=0;i<W;++i)cin>>bs[i];
	lazy_segtree aseg(H),bseg(W);
	for (int i = 0; i < H; ++i) {
		aseg.update(i,i+1, as[i]);
	}
	for (int i = 0; i < W; ++i) {
		bseg.update(i,i+1, bs[i]);
	}
	while (Q--) {
		int type;cin>>type;
		if (type == 1) {
			int a,b,x;cin>>a>>b>>x;a--;
			aseg.update(a,b,x);
		}
		else if (type == 2) {
			int a,b,x;cin>>a>>b>>x;a--;
			bseg.update(a,b,x);
		}
		else {
			int a,b,c,d;cin>>a>>b>>c>>d;
			a--;c--;
			auto a_aa=aseg.get(a,b);
			auto b_aa=bseg.get(c,d);

			map<long long int,long long int>mp;
			mp[a_aa.amin*b_aa.amin]=a_aa.min_num*b_aa.min_num;
			mp[a_aa.amax*b_aa.amin]=a_aa.max_num*b_aa.min_num;
			mp[a_aa.amin*b_aa.amax]=a_aa.min_num*b_aa.max_num;
			mp[a_aa.amax*b_aa.amax]=a_aa.max_num*b_aa.max_num;

			auto it=mp.begin();
			auto jt=prev(mp.end());

			if (type == 3) {
				long long int ans_num,ans_cnt;
				if (it->first == 0) {
					if (a_aa.amin == 0 && b_aa.amin == 0) {
						ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
					}
					else if (a_aa.amin == 0) {
						ans_cnt=(d-c)*a_aa.min_num;
					}
					else if(b_aa.amin==0){
						ans_cnt=(b-a)*b_aa.min_num;
					}
					else {
						swap(a_aa.amin,a_aa.amax);
						swap(a_aa.min_num,a_aa.max_num);
						swap(b_aa.amin,b_aa.amax);
						swap(b_aa.min_num, b_aa.max_num);

						if (a_aa.amin == 0 && b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
						}
						else if (a_aa.amin == 0) {
							ans_cnt = (d - c)*a_aa.min_num;
						}
						else if (b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num;
						}
						else {
							assert(false);
						}
					}
				}
				else {
					ans_cnt=it->second;
				}
				cout<<it->first<<" "<<ans_cnt<<endl;
			}
			else {
				long long int ans_num, ans_cnt;
				swap(b_aa.amin,b_aa.amax);
				swap(b_aa.min_num,b_aa.max_num);
				if (jt->first == 0) {
					if (a_aa.amin == 0 && b_aa.amin == 0) {
						ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
					}
					else if (a_aa.amin == 0) {
						ans_cnt = (d - c)*a_aa.min_num;
					}
					else if (b_aa.amin == 0) {
						ans_cnt = (b - a)*b_aa.min_num;
					}
					else {
						swap(a_aa.amin, a_aa.amax);
						swap(a_aa.min_num, a_aa.max_num);
						swap(b_aa.amin, b_aa.amax);
						swap(b_aa.min_num, b_aa.max_num);

						if (a_aa.amin == 0 && b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
						}
						else if (a_aa.amin == 0) {
							ans_cnt = (d - c)*a_aa.min_num;
						}
						else if (b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num;
						}
						else {
							assert(false);
						}
					}
				}
				else {
					ans_cnt = jt->second;
				}
				cout << jt->first << " " << ans_cnt << endl;
			}
		}
	}
	return 0;
}
accuracy: 0.4827586206896552
time_ms: 20
memory_kb: 4416
final_rank: 10

code_snippet: #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld =long double;
const ld eps = 1e-9;

#define Seg_Max_N (1<<18) 

struct aa {
	long long int amin;
	long long int min_num;

	long long int amax;
	long long int max_num;
};

typedef aa Value1;
typedef int Value2;
const Value1 Zero1 = aa{ 0,1,0,1 };
const Value2 Zero2 =0;

struct Node {
	Value1 sum;//更新された値. この値を参照する時は評価が完全に完了しているようにする.
	Value2 lazy;	//遅延されている値を保存している
	Node() :sum(Zero1) {
		lazy = Zero2;
	}
};
struct lazy_segtree {
	int N;
	vector<Node>dat;
	lazy_segtree(int n) :N(1) {
		while (N < n) N *= 2;
		dat.resize(2 * N);
	}

	Value2 lazy_connect(const Value2 l, const Value2 r) {
		return l+r;
	}

	void lazy_func(const int k, const int a, const int b) {
		
		dat[k].sum.amin += dat[k].lazy;
		dat[k].sum.amax+=dat[k].lazy;
		
	}

	Value1 connect(const Value1 l, const Value1 r) {
		aa naa;
		if (l.amin == r.amin) {
			naa.amin = l.amin;
			naa.min_num = l.min_num + r.min_num;
		}
		else if (l.amin > r.amin) {
			naa.amin = r.amin;
			naa.min_num = r.min_num;
		}
		else {
			naa.amin = l.amin;
			naa.min_num = l.min_num;
		}

		if (l.amax == r.amax) {
			naa.amax = l.amax;
			naa.max_num = l.max_num + r.max_num;
		}
		else if (l.amax < r.amax) {
			naa.amax = r.amax;
			naa.max_num = r.max_num;
		}
		else {
			naa.amax = l.amax;
			naa.max_num = l.max_num;
		}
		return naa;
	}

	// inlineつけないと大変なことになるよ!(遅い)
	inline void lazy_evaluate_node(int k, int a, int b) {
		lazy_func(k, a, b);
		if (k < N) { // 2*k(左の子番号) < 2*N (節点の数) のイメージで. 末端ノードじゃなきゃ伝搬するのと等価.
			dat[2 * k].lazy = lazy_connect(dat[2 * k].lazy, dat[k].lazy);	//次は君が伝搬してね☆って感じ.
			dat[2 * k + 1].lazy = lazy_connect(dat[2 * k + 1].lazy, dat[k].lazy);
		}
		dat[k].lazy = Zero2;
	}

	inline void update_node(int k) { // kの子が既に評価されていることが前提. 末端以外のときしか呼び出さないような位置に書くのでif文要らない.
		dat[k].sum = connect(dat[2 * k].sum, dat[2 * k + 1].sum);

	}

	// update(l,r,v) := [l,r)を更新する. 区間は0-indexed.
	void update(int l, int r, Value2 v, int k = 1, int a = 0, int b = -1) {
		if (b == -1)b = N;
		if (l < 0 || r < 0)assert(false);
		lazy_evaluate_node(k, a, b); 	// とりあえず辿ったノードは都合がいいので伝搬しとけ精神.

		if (b <= l || r <= a) //[a,b)と[l,r)が交差している場合
			return;
		if (l <= a && b <= r) { // [l,r)が[a,b)を完全に含んでいる場合
			dat[k].lazy = lazy_connect(dat[k].lazy, v);
			lazy_evaluate_node(k, a, b); //一回遅延評価しとかないと都合悪いので.
			return;
		}

		int m = (a + b) / 2;
		update(l, r, v, 2 * k, a, m);
		update(l, r, v, 2 * k + 1, m, b);
		update_node(k);
	}
	//get(l,r) := [l,r)に対するクエリの答えを得る. 区間は0-indexed.
	Value1 get(int l, int r, int k = 1, int a = 0, int b = -1) {
		if (b == -1)b = N;

		if (l < 0 || r<0)assert(false);
		lazy_evaluate_node(k, a, b); // とりあえず辿ったノードは都合がいいので伝搬しとけ精神.

		if (b <= l || r <= a) //[a,b)と[l,r)が交差している場合
			return aa{static_cast<long long int>(1e18),0,static_cast<long long int>(-1e18),0 };

		if (l <= a && b <= r) { // [l,r)が[a,b)を完全に含んでいる場合
			return dat[k].sum;
		}

		int m = (a + b) / 2;
		Value1 vl = get(l, r, 2 * k, a, m);
		Value1 vr = get(l, r, 2 * k + 1, m, b);
		update_node(k);
		return connect(vl, vr);
	}
};

int main()
{
	int H,W,Q;cin>>H>>W>>Q;
	vector<int>as(H),bs(W);
	for(int i=0;i<H;++i)cin>>as[i];
	for(int i=0;i<W;++i)cin>>bs[i];
	lazy_segtree aseg(H),bseg(W);
	for (int i = 0; i < H; ++i) {
		aseg.update(i,i+1, as[i]);
	}
	for (int i = 0; i < W; ++i) {
		bseg.update(i,i+1, bs[i]);
	}
	while (Q--) {
		int type;cin>>type;
		if (type == 1) {
			int a,b,x;cin>>a>>b>>x;a--;
			aseg.update(a,b,x);
		}
		else if (type == 2) {
			int a,b,x;cin>>a>>b>>x;a--;
			bseg.update(a,b,x);
		}
		else {
			int a,b,c,d;cin>>a>>b>>c>>d;
			a--;c--;
			auto a_aa=aseg.get(a,b);
			auto b_aa=bseg.get(c,d);

			map<long long int,long long int>mp;
			mp[a_aa.amin*b_aa.amin]=a_aa.min_num*b_aa.min_num;
			mp[a_aa.amax*b_aa.amin]=a_aa.max_num*b_aa.min_num;
			mp[a_aa.amin*b_aa.amax]=a_aa.min_num*b_aa.max_num;
			mp[a_aa.amax*b_aa.amax]=a_aa.max_num*b_aa.max_num;

			auto it=mp.begin();
			auto jt=prev(mp.end());

			if (type == 3) {
				long long int ans_num,ans_cnt;
				if (it->first == 0) {
					if (a_aa.amin == 0 && b_aa.amin == 0) {
						ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
					}
					else if (a_aa.amin == 0) {
						ans_cnt=(d-c)*a_aa.min_num;
					}
					else if(b_aa.amin==0){
						ans_cnt=(b-a)*b_aa.min_num;
					}
					else {
						swap(a_aa.amin,a_aa.amax);
						swap(a_aa.min_num,a_aa.max_num);
						swap(b_aa.amin,b_aa.amax);
						swap(b_aa.min_num, b_aa.max_num);

						if (a_aa.amin == 0 && b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
						}
						else if (a_aa.amin == 0) {
							ans_cnt = (d - c)*a_aa.min_num;
						}
						else if (b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num;
						}
						else {
							assert(false);
						}
					}
				}
				else {
					ans_cnt=it->second;
				}
				cout<<it->first<<" "<<ans_cnt<<endl;
			}
			else {
				long long int ans_num, ans_cnt;
				swap(b_aa.amin,b_aa.amax);
				swap(b_aa.min_num,b_aa.max_num);
				if (jt->first == 0) {
					if (a_aa.amin == 0 && b_aa.amin == 0) {
						ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
					}
					else if (a_aa.amin == 0) {
						ans_cnt = (d - c)*a_aa.min_num;
					}
					else if (b_aa.amin == 0) {
						ans_cnt = (b - a)*b_aa.min_num;
					}
					else {
						swap(a_aa.amin, a_aa.amax);
						swap(a_aa.min_num, a_aa.max_num);
						swap(b_aa.amin, b_aa.amax);
						swap(b_aa.min_num, b_aa.max_num);

						if (a_aa.amin == 0 && b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num + (d - c)*a_aa.min_num - a_aa.min_num*b_aa.min_num;
						}
						else if (a_aa.amin == 0) {
							ans_cnt = (d - c)*a_aa.min_num;
						}
						else if (b_aa.amin == 0) {
							ans_cnt = (b - a)*b_aa.min_num;
						}
						else {
							assert(false);
						}
					}
				}
				else {
					ans_cnt = jt->second;
				}
				cout << jt->first << " " << ans_cnt << endl;
			}
		}
	}
	return 0;
}
accuracy: 0.4827586206896552
time_ms: 20
memory_kb: 4412
final_rank: 9