BZOJ 3158: 千钧一发(最小割)

3158: 千钧一发

Time Limit: 10 Sec  Memory Limit: 512 MB
Submit: 648  Solved: 249
[ Submit][ Status][ Discuss]

Description

Input

第一行一个正整数N。

第二行共包括N个正整数，第 个正整数表示Ai。

第三行共包括N个正整数，第 个正整数表示Bi。

Output

共一行，包括一个正整数，表示在合法的选择条件下，可以获得的能量值总和的最大值。

Sample Input

4
3 4 5 12
9 8 30 9

Sample Output

39

HINT

1<=N<=1000,1<=Ai,Bi<=10^6

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#define LL long long 
using namespace std;
const int MAXN = 2000000 + 10;
const int INF = 0x7fffffff;
inline int read()
{
    int x = 0, f = 1; char ch = getchar();
    while(ch < '0' || ch > '9'){if(ch == '-') f=-1; ch = getchar();}
    while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0'; ch = getchar();}
    return x * f;
}
struct Edge{int to, next, cap, flow;}edge[MAXN<<2];
int tot, head[MAXN];
int gap[MAXN], dep[MAXN], pre[MAXN], cur[MAXN];
void init(){tot = 0; memset(head, -1, sizeof(head));}
void addedge(int u, int v, int w, int rw = 0)
{
    edge[tot].to = v; edge[tot].cap = w; edge[tot].next = head[u];
    edge[tot].flow = 0; head[u] = tot++;
    edge[tot].to = u; edge[tot].cap = rw; edge[tot].next = head[v];
    edge[tot].flow = 0; head[v] = tot++;
}
long long sap(int start, int end, int N)
{
    memset(gap, 0, sizeof(gap));
    memset(dep, 0, sizeof(dep));
    memcpy(cur, head, sizeof(head));
    int u = start; pre[u] = -1; gap[0] = N; long long ans = 0;
    while(dep[start] < N)
    {
        if(u == end)
        {
            long long Min = INF;
            for(int i=pre[u];i!=-1;i=pre[edge[i^1].to])
                if(Min > edge[i].cap - edge[i].flow)
                    Min = edge[i].cap - edge[i].flow;
            for(int i=pre[u];i!=-1;i=pre[edge[i^1].to])
            {
                edge[i].flow += Min;
                edge[i^1].flow -= Min;
            }
            u = start; ans += Min; continue;
        }
        bool flag = false; int v;
        for(int i=cur[u];i!=-1;i=edge[i].next)
        {
            v = edge[i].to;
            if(edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u])
            {
                flag = true;
                cur[u] = pre[v] = i;
                break;
            }
        }
        if(flag){u = v; continue;}
        int Min = N;
        for(int i=head[u];i!=-1;i=edge[i].next)
            if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min)
            {
                Min = dep[edge[i].to];
                cur[u] = i;
            }
        gap[dep[u]]--;
        if(!gap[dep[u]]) return ans;
        dep[u] = Min + 1;
        gap[dep[u]]++;
        if(u != start) u = edge[pre[u]^1].to;
    }
    return ans;
}
int n, a[1010], b[1010];
bool judge(int x, int y)
{
    x = a[x], y = a[y];
    if(__gcd(x, y) > 1) return 1;
    long long tmp = 1ll * x * x + 1ll * y * y;
    long long t = sqrt(tmp);
    if(t * t != tmp) return 1;
    return 0;
}
int main()
{
    n = read();long long ans = 0;init();
    int S = 0, T = n + 1;
    for(int i=1;i<=n;i++) a[i] = read();
    for(int i=1;i<=n;i++) b[i] = read(), ans += b[i];
    for(int i=1;i<=n;i++)
    {
        if(a[i] % 2 == 0) addedge(S, i, b[i]);
        else addedge(i, T, b[i]);
        for(int j=1;j<=n;j++)
        {
            if(a[i] % 2 == 0 && a[j] % 2 == 1)
            {
                if(!judge(i, j)) addedge(i, j, INF);
            }
        }
    }
    long long res = sap(S, T, n + 2);
    printf("%lld\n", ans - res);
    return 0;
}