工程规划【简单题解】

题目信息:

问题 F(2678): 工程规划

时间限制: 1 Sec 内存限制: 128 MB Special Judge

题目描述

造一幢大楼是一项艰巨的工程，它是由n个子任务构成的，给它们分别编号1，2，…，n(5≤n≤1000)。由于对一些任务的起始条件有着严格的限制，所以每个任务的起始时间T1，T2，…，Tn并不是很容易确定的(但这些起始时间都是非负整数，因为它们必须在整个工程开始后启动)。例如：挖掘完成后，紧接着就要打地基；但是混凝土浇筑完成后，却要等待一段时间再去掉模板。
这种要求就可以用M(5≤m≤5000)个不等式表示，不等式形如Ti – Tj ≤ b代表任务i和任务j的起始时间必须满足的条件。每个不等式的右边都是一个常数b，这些常数可能不相同，但是它们都在区间(-100，100)内。
你的任务就是写一个程序，给定像上面那样的不等式，找出一种可能的起始时间序列T1，T2，…，Tn，或者判断问题无解。对于有解的情况，要使最早进行的那个任务和整个工程的起始时间相同，也就是说，T1，T2，…，Tn中至少有一个为0。

输入

第一行是用空格隔开的两个正整数n和m

下面的m行每行有三个用空格隔开的整数i，j，b对应着不等式Ti-Tj≤b。

输出

如果有可行的方案，那么输出N行，每行都有一个非负整数且至少有一个为0，按顺序表示每个任务的起始时间。如果没有可行的方案，就输出信息“NO SOLUTION”。
样例输入
5 8
1 2 0
1 5 -1
2 5 1
3 1 5
4 1 4
4 3 -1
5 3 -1
5 4 -3
样例输出
0
2
5
4
1

题目分析:
该替中的内容含有Ti-Tj <= w w+Tj >= Ti
所以可以用图中的Dist(j)+W(j,i)<=Ti
就可以转换成求最短的距离
在选择从哪个点开始进行SPFA算法时由于不知道该从哪个点开始
所以可以假设有一个其他的点N该点连接到所有的点且距离为0
然后就可以从该点开始查找
查找完后寻找最小值再对所有的值进行正负数之间的转换和加减
代码如下：

const int INF = 100000000;
const int MAXA = 5010;
const int MAXB = 1010;
using namespace std;
struct Node{
    int v,wt;
    Node* next;
    Node(){v = wt = 0;next=NULL;}
}edge[MAXA];
int now,n,m,num;
bool vis[MAXB];
Node *List[MAXB];
int Map[MAXB][MAXB],od[MAXB];
int cnt[MAXB];
int d[MAXB],st = INF;
void addedge(int st,int ed,int w){
    now++;
    Node *nnode = &edge[now];
    nnode->next = List[st];
    nnode->v = ed;
    nnode->wt = w;
    List[st] = nnode;
}
void read()
{
    int i,u,v,w;
    scanf(“%d%d”, &n, &m);
    for(i=1; i <= m; i++){
        scanf(“%d%d%d”,&u, &v, &w);
        addedge(v,u,w);
    }
    for (int i=1;i<=n;i++)
    {
        addedge(0,i,0);
    }
}
bool flag = true;
void SPFA(int s)
{
    queue<int> q;
    memset(d,0x3f,sizeof (d));
    d[s]=0;
    vis[s]=true;
    q.push(s);
    cnt[s]++;
    int j;
    while(!q.empty())
    {
        j=q.front();
        q.pop();
        vis[j]=false;
        int k,w;
        for (Node *p=List[j];p!=NULL;p=p->next)
        {
            k=p->v;
            w=p->wt;
            if (d[k]>d[j]+w)
            {
                d[k]=d[j]+w;
                if (!vis[k])
                {
                    vis[k]=true;
                    q.push(k);
                    cnt[k]++;
                    if (cnt[k]>n)
                    {
                        flag=false;
                        return ;
                    }
                }
            }
        }
    }
}
int main()
{
    read();
    SPFA(0);
    if (flag==false)
    {
        printf (“NO SOLUTION\n”);
        return 0;
    }
    int Min = 0x3f;
    bool t=true;
    for (int j=1;j<=n;j++)
    {
        if(d[j] < Min){
            Min=d[j];
            t=false;
        }
    }
    if (t==false)
    {
        for(int i=1;i<=n;i++)
        {
            d[i]=d[i]-Min;
            printf (“%d\n”,d[i]);
        }
    }
    else
    {
        for(int i=1;i<=n;i++)
            printf (“%d\n”,d[i]);
    }
    return 0;
}