您的位置：首页 > 其它

uva 515 King

2012-11-29 19:13 288 查看

这个题目，做之前不知道什么事差束约分，看完题目上床睡觉，想了半个小时，想到了要判断一个有向图有没有负环。第二天起来再想，觉得是判断有没有环（包括负环，正环，0环），但是不确定，要真的是这样的话，要权值来干什么，直接拓扑排序就好了，然后不确定，找了解题报告瞄一下，个个都是差束约分，然后没看其他内容，直接去学差束约分，看算法导论和网上的资料看了一个小时，懂了，就写，其实就是差束约分的模板题

说说思路和题目：给你一个长度为n的序列，从下标1到n标号，然后给你m个连续的子序列，让你求和，和要大于或者小于给定的k，如果这m个不等式都能成立，就输出成功，只要有一个不成立就输出不成立。sample中第一个就是成立的，第二个不成立

然后我们先来设定一个值Xi，Xi=a1+a2+a3……+ai ；所以输入中是给出一个下标i和长度l，连续的子序列就是 ai+（ai+1）+（ai+2）……（ai+l）

那么显然就是等于（Xi+l）-（Xi-1）（长的连续和减去短的连续和，得到中间的部分），这样我们就构建出了差束约分里面的不等式

所以可以知道，虽然a序列标号是从1到n，但是X序列显然是从0到n标号的（想想就知道）

另外一个转化问题就是大于（小于）转化为大于等于（小于等于），因为说了所有数字都是整数所以这个转化很容易的

Xj-Xi>k 等价于 Xj-Xi >= k+1 Xj-Xi<k 等价于 Xj-Xi <= k-1 (因为都是整数所以可以这样做)

然后就是差束约分的有向图建图，这里是用了邻接表建图，可以处理掉平行边

最后一步，设置一个新源点Xn+1 （别忘了是从0到n标号的，所以只能设置n+1），和其余所有出现过的点相连，都是有向边，从Xn+1指向其他点，权值都是0

所以这样建图后，整个图一定是连通的，在没有负环的情况下一定有可行解，然后就是spfa求最短路，顺便判断负环，有负环就没有可行解，否则就有

（其实普通的差束约分问题，只要没有负环就有可行解，而且有一组的和就会有无数组）

还有，这道题就是判断有没有可行解，其实就是判断有没有负环（原来就是我昨天晚上想的那样，不过那时候不懂什么是差束约分也证明不了），由于是有向图而且是有负权那当然是spfa，spfa有bfs和dfs版本，两个都写在代码里面，按理论讲，单单判有没有负环的话dfs更好，不过这道题bfs和dfs的时间一样，都跑出了0.072，惊奇的是冲进去了第一名，是我第一次冲进去uva的第一名

多少要纪念一下啊，毕竟做了uva大半年了第一次冲进第一名（上一次最好成绩是第5名，也是spfa_dfs判负环）

不过怎么说呢…………这道还是水题，而且能算是模板题吧

邻接表+spfa判负环

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
#define N 110
#define M 110
#define INF 0x3f3f3f3f
struct edge
{
int u,v,w,next;
}e[M+N];
//这个数组不能只开到M，因为后面要加入一个新源点n+1，与0到n的所有顶点连接一条有向边
int first
;
int used
;  //在输入中出现过哪些点
int vis
,c
;   //spfa_dfs起标记作用
int d
;     //最短路径数组
int n,m,edgenum,s; //s是源点也就是0，edgenum是边集数组的条数

void input()
{
memset(used,0,sizeof(used));
memset(first,-1,sizeof(first));

scanf("%d",&m);
edgenum=0;
for(int k=0; k<m; k++)  //读入所有不等式，转化为边的信息,但注意边数是edgenum不是k
{
int i,j,w;  char op[5];
scanf("%d%d%s%d",&i,&j,op,&w);
j+=i; i--; //得到顶点i，j，j标号一定大于i
used[i]=used[j]=1;  //标记出现过这些点
if(!strcmp(op,"lt"))  //是小于
{
w--;  //相当于<=w-1
e[edgenum].u=i;
e[edgenum].v=j;
e[edgenum].w=w;
e[edgenum].next=first[i];
first[i]=edgenum;
edgenum++;

}
else     //大于
{
w++;  //相当于>=w+1
e[edgenum].u=j;
e[edgenum].v=i;
e[edgenum].w=-w;
e[edgenum].next=first[j];
first[j]=edgenum;
edgenum++;
}
}

used[n+1]=1;
for(int i=0; i<=n; i++)
if(used[i])  //新设置一个源点0，跟所有已有的点相连
{
e[edgenum].u=n+1;
e[edgenum].v=i;
e[edgenum].w=0;
e[edgenum].next=first[n+1];
first[n+1]=edgenum;
edgenum++;
}

return ;
}

void print_graph()
{
printf("邻接表\n");
for(int i=0; i<=n+1; i++)
if(used[i])
{
printf("%d:_____________________\n",i);
for(int k=first[i]; k!=-1; k=e[k].next)
printf("%d\\%d\n",e[k].v,e[k].w);
}
printf("*********\n");
printf("打印边集数组\n");
for(int i=0; i<edgenum; i++)
printf("%d  %d  %d  %d\n",e[i].u,e[i].v,e[i].w,e[i].next);
printf("*********\n");
return ;
}

int spfa_dfs(int u)
{
vis[u]=1;
for(int k=first[u]; k!=-1; k=e[k].next)  //遍历顶点u的邻接表
{
int v=e[k].v , w=e[k].w;
if( d[u]+w < d[v])
{
d[v]=d[u]+w;
if(!vis[v])
{
if(spfa_dfs(v))
return 1;
}
else return 1;
}
}
vis[u]=0;
return 0;
}
int spfa_bfs(int s)
{
int flag=1;
queue <int> q;
memset(c,0,sizeof(c)); c[s]++;
memset(d,0x3f,sizeof(d)); d[s]=0;
memset(vis,0,sizeof(vis)); vis[s]=1;
q.push(s);
while(!q.empty())
{
int u=q.front(); vis[u]=0; q.pop();
for(int k=first[u]; k!=-1; k=e[k].next)
{
int v=e[k].v , w=e[k].w;
if(d[u]+w<d[v])
{
d[v]=d[u]+w;
if(!vis[v])
{
vis[v]=1;
q.push(v);
c[v]++;
if(c[v]>n+1)
return 1;  //找到负环
}
}
}
}

return 0;  //没有负环
}
void judge()
{
s=n+1;  //源点
memset(d,0x3f,sizeof(d)); d[s]=0;
memset(vis,0,sizeof(vis));

//int tmp=spfa_dfs(s);
int tmp=spfa_bfs(s);
//spfa的dfs版本和bfs版本都有了，都可以AC，注释掉换过来就可以了
if(tmp)
printf("successful conspiracy\n");
else
printf("lamentable kingdom\n");

return ;
}
int main()
{
while(scanf("%d",&n) && n)
{
input();
//print_graph();  //测试函数
judge();
}
return 0;
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航