。。。 There is nothing to say about the topic.
Assign n points to two sets, and find the weights of the edges of all points in the sum= a set for each point to the B set.
n=20;
。 The brute force algorithm directly enumerates each case.
1, Violent enumeration complexity 2^19 * 20*20 complexity is slightly larger. TLE ... Add a pruning to remove half of it and run 1S. POJ's data is too water.
Enumeration can be used to use bit operations, re-use of the previous results (complexity 2^n * n), without each enumeration to sum all the values, probably can run 200ms
2, DFS, no pruning can also be 2^20* n ... 400ms, much faster than enumerations (enumerations do a lot of unnecessary additions ...)
Pruning: To seek a-b between the largest external and to the respective minimum of AB and ...
Some Daniel cut the branches directly on the 16MS ...
3. Random mess ... Every random change 1 nodes from A to B or B to a,for update the sum value, repeat 10W, basically all AC, of course, and the size of the data is related .... Reference to someone else's code is probably also 100+ms
About bitmask. has been traversing every bit of I ... It will be quicker to read someone's writing today ...
Violence enumeration + Memory:
#include <cstdio> #include <cmath> #include <cstring> #include <string> #include <algorithm&
Gt
#include <queue> #include <map> #include <stack> #include <iostream> using namespace std;
Double eps=0.000001;
int tm[25][25];
int set[25];
int vis[5+ (1<<20)];
int f[5+ (1<<20)];
int main () {int st,i,j,k;
int n;
cin>>n;
for (i=1;i<=n;i++) {for (j=1;j<=n;j++) {scanf ("%d", &tm[i][j]);
} int maxx=0;
int all=1<< (n)-1;
for (k=1;k<all;k++) {if (vis[k]) continue;
Vis[k]=1; Vis[k^all]=1; Pruning 1/2, so that the complexity becomes 2^ (n-1)//-k&k is the lowbit bit of K (the lowest edge of 1)//k-lowbit (k) to get the "a set" of the last state//then the current state of the sum value f[k]=f[last]+ the current new point
The sum int lowbit=-k&k; of a set to x before the sum-of the x to the B set
int last=k-lowbit;
F[k]=f[last]; int x=0;
J is the new Point while (Lowbit) {x++;lowbit>>=1}
for (j=1;j<=n;j++) {if (1<< (j-1)) &last)//means J already in a set f[k]-=tm[x][j]; else//j in B set F[k]+=tm[x]
[j];
} F[k^all]=f[k];
if (F[k]>maxx) maxx=f[k];
printf ("%d\n", Maxx);
return 0; }
Brute Force enumeration code: 1S
#include <cstdio> #include <cmath> #include <cstring> #include <string> #include <algorithm&
Gt
#include <queue> #include <map> #include <stack> #include <iostream> using namespace std;
__int64 inf=15;
Double eps=0.000001;
int tm[25][25];
int set[25];
int vis[1<<20+5];
int main () {int st,i,j,k;
int n;
cin>>n;
for (i=1;i<=n;i++) {for (j=1;j<=n;j++) {scanf ("%d", &tm[i][j]);
}} __int64 maxx=0;
int all=1<< (n)-1;
for (k=0;k<=all;k++) {if (vis[k]) continue;
Vis[k]=1; Vis[k^all]=1;
Pruning 1/2 makes the complexity become 2^ (n-1) set[1]++;
for (i=1;i<=n;i++) {if (set[i]==2) {set[i]=0;
set[i+1]++;
else break;
} __int64 sum=0;
for (i=1;i<=n;i++) {if (!set[i]) continue;
for (j=1;j<=n;j++) {if (!set[j]) sum+=tm[i][j];
} if (Sum>maxx) maxx=sum;
printf ("%i64d\n", Maxx);
return 0; }
Dfs:200ms
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
# Include <algorithm>
#include <queue>
#include <map>
#include <stack>
# Include <iostream>
using namespace std;
Double eps=0.000001;
int tmd[25][25];
int set[25];
int Maxx;
int n;
int dfs (int x,int sum)
{
if (x>n)
{
if (Sum>maxx)
maxx=sum;
return 0;
}
int tmdp=0,i;set[x]=0;
for (i=1;i<=x;i++)
{
if (!set[i]) continue;
tmdp+=tmd[i][x];//does not select X into A,sum+=[x to set A and]
}
dfs (X+1,SUM+TMDP);
Tmdp=0;
Set[x]=1;
for (i=1;i<=x;i++)
{
if (set[i]) continue;
TMDP+=TMD[I][X]; Select X to A,sum+=[x to B-set and]
}
dfs (X+1,SUM+TMDP);
}
int main ()
{
int st,i,j,k;
int t;
cin>>n;
for (i=1;i<=n;i++)
{
for (j=1;j<=n;j++)
{
scanf ("%d", &tmd[i][j]);
}
maxx=0;
DFS (1,0);
printf ("%d\n", Maxx);
return 0;
}
Random mess: http://blog.csdn.net/sssogs/article/details/8221244