• A+B Problem


    真 是 一 道 好 题

    其实这道题并不难,可以用线段树过这题。

    #include <bits/stdc++.h>
    #define re register
    #define lson (ind<<1)
    #define rson (ind<<1|1)
    using namespace std;
    typedef long long ll;
    
    const int maxn = 100005;
    int n, a[maxn]; 
    int l[maxn<<2], r[maxn<<2], mx[maxn<<2], mn[maxn<<2], tag[maxn<<2];
    ll val[maxn<<2], ans;
    
    inline ll read() {
    	ll ret = 0, flag = 1;
    	char ch = getchar();
    	while (ch > '9' || ch < '0') {
    		ch = getchar();
                    if (ch = '-') flag = -1;
    	}
    	while (ch <= '9' && ch >= '0') {
    		ret = (ret << 1) + (ret << 3) + (ch ^ '0'); 
    		ch = getchar();
    	}
    	return ret * flag;
    }
    
    inline void write(re ll num) {
    	if (num > 9) {
    		write(num/10);
    	}
    	putchar(num%10+'0');
    }
    
    inline void pushup(re int ind) {
    	val[ind] = val[lson] + val[rson];
    	mx[ind] = mx[lson];
    	mn[ind] = mn[rson];
    }
    
    inline void change(re int ind, re int v) {
    	mx[ind] += v; mn[ind] += v; tag[ind] += v; val[ind] += 1ll * v * (r[ind] - l[ind] + 1);
    }
    
    inline void build(re int le, re int ri, re int ind) {
    	if (le == ri) {
    		l[ind] = r[ind] = le;
    		val[ind] = mx[ind] = mn[ind] = a[le];
    		return;
    	}
    	re int mid = (le + ri) >> 1;
    	build(le, mid, lson);
    	build(mid+1, ri, rson);
    	l[ind] = le, r[ind] = ri;
    	pushup(ind);
    }
    
    inline void pushdown(re int ind) {
    	if (!tag[ind]) return;
    	change(lson, tag[ind]);
    	change(rson, tag[ind]);
    	tag[ind] = 0;
    }
    
    inline void update(re int x, re int y, re int v, re int ind) {
    	if (x > r[ind] || y < l[ind]) return;
    	else if (x <= l[ind] && y >= r[ind]) {
    		change(ind, v);
    		return;
    	}
    	re int mid = (l[ind]+r[ind])>>1;
    	pushdown(ind);
    	if (mid >= x) update(x, y, v, lson);
    	if (mid < y) update(x, y, v, rson);
    	pushup(ind);
    }
    
    inline ll query_sum(re int x, re int y, re int ind) {
    	if (x > r[ind] || y < l[ind]) return 0;
    	else if (x <= l[ind] && y >= r[ind]) {
    		return val[ind];
    	}
    	pushdown(ind);
    	return query_sum(x, y, lson) + query_sum(x, y, rson);
    }
    
    inline ll query_max(re int x, re int y, re int ind) {
    	if (x > r[ind] || y < l[ind]) return 0;
    	else if (x <= l[ind] && y >= r[ind]) {
    		return val[ind];
    	}
    	pushdown(ind);
    	return max(query_max(x, y, lson), query_max(x, y, rson));
    }
    
    
    inline ll query_min(re int x, re int y, re int ind) {
    	if (x > r[ind] || y < l[ind]) return 0x7fffffff;
    	else if (x <= l[ind] && y >= r[ind]) {
    		return val[ind];
    	}
    	pushdown(ind);
    	return min(query_min(x, y, lson), query_min(x, y, rson));
    }
    
    ll x, y;
    
    int main() {
    	x = read(); y = read();
            build(1, 100000, 1);
            update(1, 1, x, 1);
            update(2, 2, y, 1);
            ans = query_sum(1, 2, 1);
            write(ans); puts("");
    	return 0;
    } 
    

    后来发现,神犇们还有更短的AC代码
    半死不活的SPFA

    #include <bits/stdc++.h>
    using namespace std;
    typedef long long ll;
     
    ll head[100005], pre[100005], to[100005], val[100005], len;
    ll dis[100005], vis[100005]; 
     
    void insert(ll u, ll v, ll w) {
    	to[++len] = v; pre[len] = head[u]; val[len] = w; head[u] = len;
    } 
    
    void SPFA(ll root) {
    	queue<ll> q;
    	q.push(root);
    	while (!q.empty()) {
    		ll x = q.front();
    		q.pop();
    		for (ll i = head[x]; i; i = pre[i]) {
    			ll y = to[i];
    			if (dis[y] > dis[x] + val[i]) {
    				dis[y] = dis[x] + val[i];
    				if (!vis[y]) {
    					q.push(y);
    					vis[y] = 1;
    				}
    			}
    		}
    		vis[x] = 0;
    	}
    }
    
    ll x, y;
     
    int main() {
    	scanf("%lld %lld", &x, &y);
    	insert(1, 2, x);
    	insert(2, 3, y);
    	memset(dis, 0x7f, sizeof(dis));
    	dis[1] = 0;
    	SPFA(1);
    	printf("%lld
    ", dis[3]);
    	return 0;
    }
    

    还有巨佬用网络流AC此题

    #include <bits/stdc++.h>
    using namespace std;
    typedef long long ll;
     
    struct Edge{
    	ll pre, to, val;
    }edge[100005];
     
    ll head[100005], cur[100005], len;
    ll d[100005];
    ll s = 0, t = 3;
    ll ans;
    const ll inf = 0x7fffffffffffffff;
     
    void insert(ll x, ll y, ll z) {
    	edge[++len].pre = head[x]; edge[len].to = y; edge[len].val = z; head[x] = len;
    } 
     
    bool bfs() {
    	queue<ll> q;
    	memset(d, -1, sizeof(d));
    	d[s] = 1;
    	q.push(s);
    	ll x, y;
    	while (!q.empty()) {
    		x = q.front(); q.pop();
    		for (ll i = head[x]; i; i = edge[i].pre) {
    			y = edge[i].to;
    			if (d[y] == -1 && edge[i].val > 0) {
    				d[y] = d[x] + 1;
    				q.push(y);
    			}
    		}
    	}
    	if (d[t] == -1) return false;
    	memcpy(cur, head, sizeof(cur));
    	return true;
    }
    
    ll dfs(ll x, ll flow) {
    	if (x == t) return flow;
    	ll ret = 0, y, p;
    	for (ll &i = cur[x]; i; i = edge[i].pre) {
    		y = edge[i].to;
    		if (d[y] == d[x] + 1 && edge[i].val > 0) {
    			p = dfs(y, min(flow - ret, edge[i].val));
    			if (p) {
    				edge[i].val -= p;
    				edge[i^1].val += p;
    				ret += p;
    				if (ret == flow) return ret;
    			}
    		}
    	}
    	d[x] = -1;
    	return ret;
    }
    
    ll dinic() {
    	ll c = 0; 
    	ll p;
    	while (bfs()) {
    		p = dfs(s, inf);
    		while (p) {
    			c += p;
    			p = dfs(s, inf);
    		}
    	}
    	return c;
    }
     
    ll x, y; 
     
    int main() {
    	scanf("%lld %lld", &x, &y);
    	insert(0, 1, x);
    	insert(1, 3, x);
    	insert(0, 2, y);
    	insert(2, 3, y);
    	ans = dinic();
    	printf("%lld
    ", ans);
    	return 0;
    }
    

    %%%orz
    最小生成树

    #include <bits/stdc++.h>
    using namespace std;
    typedef long long ll;
     
    struct Edge{
    	ll from, to, val;
    }edge[100005];
     
    ll len, fa[100005];
     
    void insert(ll x, ll y, ll z) {
    	edge[++len].from = x; edge[len].to = y; edge[len].val = z;
    } 
     
    ll x, y, ans; 
    
    bool cmp(Edge a, Edge b) {
    	return a.val < b.val;
    }
    
    ll get(ll x) {
    	if (x == fa[x]) return x;
    	else return fa[x] = get(fa[x]);
    }
     
    void kruskal() {
    	sort(edge + 1, edge + len + 1, cmp);
    	for (int i = 1; i <= 2; i++) fa[i] = i;
    	for (int i = 1; i <= len; i++) {
    		ll tx = get(edge[i].from);
    		ll ty = get(edge[i].to);
    		if (tx != ty) {
    			fa[tx] = ty;
    			ans += edge[i].val;
    		}
    	}
    } 
     
    int main() {
    	scanf("%lld %lld", &x, &y);
    	insert(1, 2, x);
    	insert(2, 3, y);
    	kruskal();
    	printf("%lld
    ", ans);
    	return 0;
    }
    

    一句话代码

    #include <iostream>
    #define What using
    #define a namespace
    #define fantastic std;
    #define problem signed
    #define A main(){
    #define Plus int
    #define B x,y;
    #define Problem cin>>x>>y;
    #define is cout<<x+y;  }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    What a fantastic problem A Plus B Problem is
    
  • 相关阅读:
    XAML中的戏法
    提前预览Visual Studio 2010
    大道至简
    Windows Service下的MessageBox
    WPF中使用Expression Encoder SDK开发流媒体
    使用latex
    [zz]2D动画制作工具比较
    android platform_frameworks_base
    Fast and easy high resolution fractals with a pixel shader
    Bézier Surface
  • 原文地址:https://www.cnblogs.com/ak-dream/p/A_B_Problem.html
Copyright © 2020-2023  润新知