BZOJ 3218: a + b Problem

3218: a + b Problem

Time Limit: 20 Sec  Memory Limit: 40 MB
Submit: 1280  Solved: 481
[Submit][Status][Discuss]

Description

 

 

[Submit][Status][Discuss]

 

 

 

用可持久化线段树优化边的数量,跑最小割求答案.

 

#include <cstdio>
#include <cstring>

namespace read
{
    inline char Char(void)
    {
        static const int siz = 1 << 20;
        
        static char buf[siz];
        static char *hd = buf + siz;
        static char *tl = buf + siz;
        
        if (hd == tl)
            fread(hd = buf, 1, siz, stdin);
        
        return *hd++;
    }
    
    inline int Int(void)
    {
        register int ret = 0, neg = 0, c = Char();
        
        for (; c < 48; c = Char())
            if (c == '-')neg ^= true;
        
        for (; c > 47; c = Char())
            ret = ret * 10 + c - '0';
        
        return neg ? -ret : ret;
    }
}

const int inf = 1e9 + 7;

namespace network 
{
    int S, T;
    int hd[200005];
    int to[1000005];
    int nt[1000005];
    int fl[1000005];
    
    inline void add(int u, int v, int f)
    {
        static int edge = 0, init = 1;
        
        if (init)memset(hd, -1, sizeof(hd)), init = 0;
        
        nt[edge] = hd[u]; to[edge] = v; fl[edge] = f; hd[u] = edge++;
        nt[edge] = hd[v]; to[edge] = u; fl[edge] = 0; hd[v] = edge++;
    }
    
    int dep[200005];
    
    inline bool bfs(void)
    {
        static int que[200005], l, r;
        memset(dep, 0, sizeof(dep));
        dep[que[l = 0] = S] = r = 1;
        
        while (l != r)
        {
            int u = que[l++], v; 
            
            for (int i = hd[u]; ~i; i = nt[i])
                if (fl[i] && !dep[v = to[i]])
                    dep[que[r++] = v] = dep[u] + 1;
        }
        
        return dep[T];
    }
    
    inline int min(const int &a, const int &b)
    {
        return a < b ? a : b;
    }
    
    int cur[200005];
    
    int dfs(int u, int f)
    {
        if (u == T || !f)
            return f;
        
        int used = 0, flow, v;
        
        for (int i = cur[u]; ~i; i = nt[i])
            if (fl[i] && dep[v = to[i]] == dep[u] + 1)
            {
                flow = dfs(v, min(f - used, fl[i]));
                
                used += flow;
                fl[i] -= flow;
                fl[i^1] += flow;
                
                if (fl[i])
                    cur[u] = i;
                
                if (f == used)
                    return f;
            }
        
        if (!used)
            dep[u] = 0;
        
        return used;
    }
    
    inline long long maxFlow(void)
    {
        long long maxFlow = 0, newFlow;
        
        while (bfs())
        {
            memcpy(cur, hd, sizeof(cur));
            
            while (newFlow = dfs(S, inf))
                maxFlow += newFlow;
        }
        
        return maxFlow;
    }
    
    inline long long minCut(void)
    {
        return maxFlow();
    }
}

int pos[5005][2], ID;

namespace segtree
{
    struct node
    {
        int id;
        int cnt;
        node *ls;
        node *rs;
    };
    
    node *root[5005];
    
    inline node *newnode(int _cnt, node *_ls, node *_rs)
    {
        static node buf[200005], *hd = buf;
        
        hd->ls = _ls;
        hd->rs = _rs;
        hd->id = ++ID;
        hd->cnt = _cnt;
        
        return hd++;
    }
    
    node *insert(node *f, int l, int r, int pos, int fr)
    {
        node *ret;
        
        if (l == r)
            ret = newnode(f->cnt + 1, 0, 0);
        else
        {
            int mid = (l + r) >> 1;
            
            if (pos <= mid)
                ret = newnode(f->cnt + 1, insert(f->ls, l, mid, pos, fr), f->rs);
            else
                ret = newnode(f->cnt + 1, f->ls, insert(f->rs, mid + 1, r, pos, fr));
        }
        
        network::add(fr, ret->id, inf);
        network::add(f->id, ret->id, inf);
        
        return ret;
    }
    
    void travel(node *t, int l, int r, int x, int y, int to)
    {
        if (t->cnt == 0)return;
        
        if (l == x && r == y)
            network::add(t->id, to, inf);
        else
        {
            int mid = (l + r) >> 1;
            
            if (y <= mid)
                travel(t->ls, l, mid, x, y, to);
            else if (x > mid)
                travel(t->rs, mid + 1, r, x, y, to);
            else
            {
                travel(t->ls, l, mid, x, mid, to);
                travel(t->rs, mid + 1, r, mid + 1, y, to);
            }
        }
    }
    
    inline void init(void)
    {
        memset(root, 0, sizeof(root));
        root[0] = newnode(0, 0, 0);
        root[0]->ls = root[0];
        root[0]->rs = root[0];
    }
}

signed main(void) 
{
    int n = read::Int();
    
    long long answer = 0;
    
    for (int i = 1; i <= n; ++i)
        pos[i][0] = ++ID,
        pos[i][1] = ++ID;
    
    segtree::init();
    
    using network::S;
    using network::T;
    
    S = 0, T = ++ID;
    
    for (int i = 1; i <= n; ++i)
    {
        using read::Int;
        using network::add;
        using segtree::root;
        using segtree::insert;
        using segtree::travel;
        
        int a = Int();
        int b = Int();
        int w = Int();
        int l = Int();
        int r = Int();
        int p = Int();
        
        answer += w;
        answer += b;
        
        add(S, pos[i][0], w);
        add(pos[i][0], T, b);
        add(pos[i][1], pos[i][0], p);
        
        static const int mx = 1000000000;
        
        root[i] = insert(root[i - 1], 0, mx, a, pos[i][0]);
        travel(root[i - 1], 0, mx, l, r, pos[i][1]);
    }
    
    printf("%lld\n", answer - network::minCut());
}
/* 
Sample Input
10
0 1 7 3 9 2
7 4 0 9 10 5
1 0 4 2 10 2
7 9 1 5 7 2
6 3 5 3 6 2
6 6 4 1 8 1
6 1 6 0 6 5
2 2 5 0 9 3
5 1 3 0 2 5
5 6 7 1 1 2

Sample Output
55
*/

 

@Author: YouSiki