题意：
有n个人，任意两个人都比一次赛（一共比了n*(n-1)/2场），赢一场得到一分，最后的时候如果得分最高，或者是自己打败了所有比自己得分都高的人就算是King,给你每个人的最后得分，问最多有多少个人是King.
思路：
一开始上了就贪心了一次，WA了，改了改之后又贪心了一次，还是没过，然后换思路（其实做这个题目是本着最大流来的），然后就去考虑最大流，最大流的话也比较容易理解，关键是枚举的时候有点说道，先说下建图，把每个人看成一个点，然后把每场比赛看成一个点，源点连接所有人，流量为得分，所有比赛连接汇点，流量1，说到这估计大多数都能建图了吧，接着说，然后就是对于那些King的点，如果和他相关的比赛节点中的另一个点比他分高，那么他一定要赢这场比赛，那么他连接这场比赛的点，否则的话就是不确定，谁赢都行，那么和这场比赛相关的两个点都连接这场比赛就行了，最多11个人左右吧，那么可以直接枚举谁是King,最保守而且没争议的方法就是暴力搜索枚举，就是01枚举，2^10*最大流时间，这个完全可以接受，然后就是网上说的那种直接枚举个数的说法，这个说法要明确一个问题，那就是如果当前有m个King,那么这m个不一定必须是后m个，也可以是中间的一些个，但是按照结论反推可以知道，这m个可以是后m个，也就是说即使不是后m个也可以转换成后m个，所以直接枚举后m就行，关键是要明白不是后m个是怎么可以转换成后m个的，我的想法一开始是找两个点，假设1..i..j..n,假如i是King,而j不是，那么就想办法吧ij的关系调换，就是让i变成不是King,而j是King,按照结论反推肯定是可以调换的，但是我想了很多方法都没有平衡掉ij之间的数字，找网上的也没有可以让我信服的，但是我自己有一个猜想，那就是我感觉可以按照贪心的方式去理解，越往后的称为King的代价就越小，也就是消耗的总的固定流量就越小，那么当然是越往后越可能了，枚举当然那是从后面开始，还有一个问题就是我感觉如果当前序列有k个可以称为King的话，那么一定可以转换成后k个，但是如果当前是后k个的话，不一定能往前转换，也就是我感觉后k个是最优的选择，就是类似那种后k个可以，但是还余出来一些资源没用，通过这些资源可以吧后k个中的一些挪到前面来，这样就产生了答案不以为的情况，但是直接枚举后k个是最优的方式，所有是正确的，这个也只是自己的感觉而已，已过想证明必须要把得分平衡掉。。。。下面是两种方法的代码，我的流用的是DINIC，估计姿势不优吧，速度和网上别人的速度比慢了很多.
DFS+DINIC
#include<queue>
#include<stdio.h>
#include<string.h>
#define N_node 150
#define N_edge 5000
#define INF 1000000000
using namespace std;
typedef struct
{
int to ,cost ,next;
}STAR;
typedef struct
{
int x ,t;
}DEP;
STAR E[N_edge];
DEP xin ,tou;
int list[N_node] ,listt[N_node] ,tot;
int deep[N_node];
void add(int a ,int b ,int c)
{
E[++tot].to = b;
E[tot].cost = c;
E[tot].next = list[a];
list[a] = tot;
E[++tot].to = a;
E[tot].cost = 0;
E[tot].next = list[b];
list[b] = tot;
}
int minn(int x ,int y)
{
return x < y ? x : y;
}
bool BFS_DEEP(int s ,int t ,int n)
{
memset(deep ,255 ,sizeof(deep));
xin.x = s ,xin.t = 0;
queue<DEP>q;
q.push(xin);
deep[s] = 0;
while(!q.empty())
{
tou = q.front();
q.pop();
for(int k = list[tou.x] ;k ;k = E[k].next)
{
xin.x = E[k].to;
xin.t = tou.t + 1;
if(deep[xin.x] != -1 || !E[k].cost)
continue;
deep[xin.x] = xin.t;
q.push(xin);
}
}
for(int i = 0 ;i <= n ;i ++)
listt[i] = list[i];
return deep[t] != -1;
}
int DFS_Flow(int s ,int t ,int flow)
{
if(s == t) return flow;
int nowflow = 0;
for(int k = listt[s] ;k ;k = E[k].next)
{
listt[s] = k;
int c = E[k].cost;
int to = E[k].to;
if(!c || deep[to] != deep[s] + 1)
continue;
int tmp = DFS_Flow(to ,t ,minn(c ,flow - nowflow));
nowflow += tmp;
E[k].cost -= tmp;
E[k^1].cost += tmp;
if(nowflow == flow) break;
}
if(!nowflow) deep[s] = 0;
return nowflow;
}
int DINIC(int s ,int t ,int n)
{
int ans = 0;
while(BFS_DEEP(s ,t ,n))
{
ans += DFS_Flow(s ,t ,INF);
}
return ans;
}
int now[15] ,num[15];
int Ans ,maxn ,n;
void Flow()
{
memset(list ,0 ,sizeof(list));
tot = 1;
for(int i = 1 ;i <= n ;i ++)
add(0 ,i ,num[i]);
int nowid = n;
for(int i = 1 ;i <= n ;i ++)
for(int j = i + 1 ;j <= n ;j ++)
{
++nowid;
if(num[i] < num[j] && now[i])
add(i ,nowid ,1);
else if(num[j] < num[i] && now[j])
add(j ,nowid ,1);
else add(i ,nowid ,1) ,add(j ,nowid ,1);
add(nowid ,n + n * (n - 1) / 2 + 1 ,1);
}
int flow = DINIC(0 ,n + n * (n - 1) / 2 + 1 ,n + n * (n - 1) / 2 + 1);
if(flow == n * (n - 1) / 2)
{
int s = 0;
for(int i = 1 ;i <= n ;i ++)
s += now[i];
if(Ans < s) Ans = s;
}
return ;
}
void DFS(int nowid)
{
if(nowid == maxn + 1)
{
Flow();
return;
}
now[nowid] = 0;
DFS(nowid + 1);
now[nowid] = 1;
DFS(nowid + 1);
}
int main ()
{
int t ,i ,nowid;
char str[30];
scanf("%d" ,&t);
getchar();
while(t--)
{
gets(str);
int len = strlen(str);
nowid = 0;
for(i = 0 ;i < len ;i ++)
{
if(str[i] >= '0' && str[i] <= '9')
{
if(i == len - 1 || str[i+1] < '0' || str[i+1] > '9')
num[++nowid] = str[i] - '0';
else
{
num[++nowid] = (str[i] - '0') * 10 + str[i+1] - '0';
i ++;
}
}
}
n = nowid;
for(i = n ;i >= 1 ;i --)
{
if(num[i] == num[n])
{
maxn = i;
now[i] = 1;
}
else now[i] = 0;
}
if(maxn == 1)
{
printf("%d\n" ,n);
continue;
}
Ans = 0;
DFS(1);
printf("%d\n" ,Ans);
}
return 0;
}
枚举后几位+DINIC
#include<queue>
#include<stdio.h>
#include<string.h>
#define N_node 150
#define N_edge 5000
#define INF 1000000000
using namespace std;
typedef struct
{
int to ,cost ,next;
}STAR;
typedef struct
{
int x ,t;
}DEP;
STAR E[N_edge];
DEP xin ,tou;
int list[N_node] ,listt[N_node] ,tot;
int deep[N_node];
int num[15];
void add(int a ,int b ,int c)
{
E[++tot].to = b;
E[tot].cost = c;
E[tot].next = list[a];
list[a] = tot;
E[++tot].to = a;
E[tot].cost = 0;
E[tot].next = list[b];
list[b] = tot;
}
int minn(int x ,int y)
{
return x < y ? x : y;
}
bool BFS_DEEP(int s ,int t ,int n)
{
memset(deep ,255 ,sizeof(deep));
xin.x = s ,xin.t = 0;
queue<DEP>q;
q.push(xin);
deep[s] = 0;
while(!q.empty())
{
tou = q.front();
q.pop();
for(int k = list[tou.x] ;k ;k = E[k].next)
{
xin.x = E[k].to;
xin.t = tou.t + 1;
if(deep[xin.x] != -1 || !E[k].cost)
continue;
deep[xin.x] = xin.t;
q.push(xin);
}
}
for(int i = 0 ;i <= n ;i ++)
listt[i] = list[i];
return deep[t] != -1;
}
int DFS_Flow(int s ,int t ,int flow)
{
if(s == t) return flow;
int nowflow = 0;
for(int k = listt[s] ;k ;k = E[k].next)
{
listt[s] = k;
int c = E[k].cost;
int to = E[k].to;
if(!c || deep[to] != deep[s] + 1)
continue;
int tmp = DFS_Flow(to ,t ,minn(c ,flow - nowflow));
nowflow += tmp;
E[k].cost -= tmp;
E[k^1].cost += tmp;
if(nowflow == flow) break;
}
if(!nowflow) deep[s] = 0;
return nowflow;
}
int DINIC(int s ,int t ,int n)
{
int ans = 0;
while(BFS_DEEP(s ,t ,n))
{
ans += DFS_Flow(s ,t ,INF);
}
return ans;
}
int Flow(int now ,int n)
{
memset(list ,0 ,sizeof(list));
tot = 1;
int s = 0 ,t = n + n * (n - 1) / 2 + 1;
for(int i = 1 ;i <= n ;i ++)
add(s ,i ,num[i]);
int nowid = n;
for(int i = 1 ;i <= n ;i ++)
for(int j = i + 1 ;j <= n ;j ++)
{
++nowid;
if(num[i] < num[j] && i >= now)
add(i ,nowid ,1);
else if(num[j] < num[i] && j >= now)
add(j ,nowid ,1);
else add(i ,nowid ,1) ,add(j ,nowid ,1);
add(nowid ,t ,1);
}
return DINIC(s ,t ,t);
}
int main ()
{
int i ,nowid ,t;
char str[30];
scanf("%d" ,&t);
getchar();
while(t--)
{
gets(str);
int len = strlen(str);
nowid = 0;
for(i = 0 ;i < len ;i ++)
{
if(str[i] >= '0' && str[i] <= '9')
{
if(i == len - 1 || str[i+1] < '0' || str[i + 1] > '9')
num[++nowid] = str[i] - '0';
else
{
num[++nowid] = (str[i] - '0') * 10 + str[i+1] - '0';
i ++;
}
}
}
int list;
for(i = nowid ;i >= 1 ;i --)
if(num[i] == num[nowid]) list = i;
if(list == 1)
{
printf("%d\n" ,nowid);
continue;
}
for(i = 1 ;i <= nowid ;i ++)
{
if(Flow(i ,nowid) == nowid * (nowid - 1) / 2)
break;
}
printf("%d\n" ,nowid - i + 1);
}
return 0;
}
