bzoj 3275 最小割

给你一堆东西，叫你选一些东西出来，使得价值最大，要求选出的东西集合中的任意a,b满足性质p。

可以考虑：

　　1、拟阵？

　　2、二分图？

这道题由于数学硬伤，不知道不存在两条直角边是奇数，斜边是整数的直角三角形。

证明是：

　　对于奇数a: a*a = 1 mod 4

　　对于偶数a: a*a = 0 mod 4

　　所以对于两个奇数a,b: a*a+b*b = 2 mod 4

　　不存在整数c使得： a*a+b*b = c*c mod 4

 /**************************************************************
     Problem: 3275
     User: idy002
     Language: C++
     Result: Accepted
     Time:3616 ms
     Memory:1176 kb
 ****************************************************************/

 #include <cstdio>
 #include <cmath>
 #include <cstring>
 #include <vector>
 #define min(a,b) ((a)<(b)?(a):(b))
 #define oo 0x3f3f3f3f
 #define N 6010
 using namespace std;

 typedef long long dnt;
 struct Edge {
     int u, v, f;
     Edge( int u, int v, int f ):u(u),v(v),f(f){}
 };
 struct Dinic {
     int src, dst;
     vector<Edge> edge;
     vector<int> g[N];
     int dep[N], cur[N], qu[N], bg, ed;
     void init( int src, int dst ) {
         this->src = src;
         this->dst = dst;
     }
     void adde( int u, int v, int f ) {
         g[u].push_back( edge.size() );
         edge.push_back( Edge(u,v,f) );
         g[v].push_back( edge.size() );
         edge.push_back( Edge(v,u,) );
     }
     bool bfs() {
         memset( dep, , sizeof(dep) );
         qu[bg=ed=] = src;
         dep[src] = ;
         while( bg<=ed ) {
             int u=qu[bg++];
             for( int t=; t<g[u].size(); t++ ) {
                 Edge &e = edge[g[u][t]];
                 if( e.f && !dep[e.v] ) {
                     dep[e.v] = dep[e.u] + ;
                     qu[++ed] = e.v;
                 }
             }
         }
         return dep[dst];
     }
     int dfs( int u, int a ) {
         if( u==dst || a== ) return a;
         int remain=a, past=, na;
         for( int &t=cur[u]; t<g[u].size(); t++ ) {
             Edge &e=edge[g[u][t]];
             Edge &ve=edge[g[u][t]^];
             if( e.f && dep[e.v]==dep[e.u]+ && (na=dfs(e.v,min(remain,e.f))) ) {
                 remain -= na;
                 past += na;
                 e.f -= na;
                 ve.f += na;
                 if( !remain ) break;
             }
         }
         return past;
     }
     int maxflow() {
         int rt=;
         while( bfs() ) {
             memset( cur, , sizeof(cur) );
             rt += dfs(src,oo);
         }
         return rt;
     }
 }D;

 int n;
 int src, dst;
 int aa[N], sum;
 int gcd( int a, int b ) {
     return b ? gcd(b,a%b) : a;
 }
 bool ok( int a, int b ) {
     if( gcd(a,b)!= ) return false;
     dnt cc = (dnt)a*a + (dnt)b*b;
     dnt c = (dnt)sqrt(cc);
     if( c*c!=cc && (c+)*(c+)!=cc ) return false;
     return true;
 }
 int main() {
     scanf( "%d", &n );
     src = n+, dst = n+;
     D.init( src, dst );
     for( int i=; i<=n; i++ ) {
         scanf( "%d", aa+i );
         sum += aa[i];
         if( aa[i]& )
             D.adde( src, i, aa[i] );
         else
             D.adde( i, dst, aa[i] );
     }
     for( int i=; i<=n; i++ ) {
         if( !(aa[i]&) ) continue;
         for( int j=; j<=n; j++ ) {
             if( aa[j]& ) continue;
             if( !ok(aa[i],aa[j]) ) continue;
             D.adde( i, j, oo );
         }
     }
     printf( "%d\n", sum-D.maxflow() );
 }