ShortestPath:Layout(POJ 3169)（差分约束的应用）

　　　　　　　　　     　　　　　　　

　　　　　　　　　　　　　　　         布局

　　题目大意：有N头牛，编号1-N，按编号排成一排准备吃东西，有些牛的关系比较好，所以希望他们不超过一定的距离，也有一些牛的关系很不好，所以希望彼此之间要满足某个关系，牛可以挤在同一个位置上，现在给出N个牛的信息，问你能否实现一种排列方案，使得d[1]到d[N]最大？如果不存在输出-1，无限大输出-2

　　这一题看上去挺难的，但是如果你知道差分约束原理，这一题似乎还是挺简单的。

　　差分约束的原理是：存在任意线性方程，满足d[A]+c>=d[B]，就可以表示为图的最短路形式，方程可以表示为A->B，权值为c的边，最后任意点之间距离之差的最大值，即为两点之间的最短距离。

　　在最短路的算法中，恒有d[u]+w>=d[s](s是源点，w是权值，u是除了s的任意点)，则d[u]-d[s]的最大值即为s-u的最短路经长。

　　回到题目上来，那么这一题事实上蕴含了三个线性方程：

　　　　1.d[i+1]>=d[i]（按照编号排序）

　　　　2.d[BL]-d[AL]<=DL->->->d[AL]+DL>=d[BL]

　　　　3.d[BD]-D[AD]>=DD->->->d[BD]-DD>=d[AD]

　　　　则我们只用把这些边表示出来算最短路径就可以了，这一题有负值边，用Bellman_Ford或者SPFA就可以了

　　

Bellman_Ford:

#include <iostream>
#include <functional>
#include <algorithm>
#define MAX 0x7f7f7f7f

using namespace std;

typedef int Positon;
typedef struct least_
{
    Positon A;
    Positon B;
    int cost;
}Relation;

static Relation L_Set[1000005],M_Set[1000005];
static int dist[1005];

void Bellman_Ford(const int, const int, const int);

int main(void)
{
    int cows_sum, ML, MD;
    while (~scanf("%d%d%d", &cows_sum, &ML, &MD))
    {
        for (int i = 0; i < ML; i++)
            scanf("%d%d%d", &L_Set[i].A, &L_Set[i].B, &L_Set[i].cost);
        for (int i = 0; i < MD; i++)
            scanf("%d%d%d", &M_Set[i].A, &M_Set[i].B, &M_Set[i].cost);
        Bellman_Ford(cows_sum, ML, MD);
    }
    return 0;
}

void Bellman_Ford(const int cows_sum, const int ML, const int MD)
{
    memset(dist, 0x7f, sizeof(dist));
    dist[1] = 0;//到自己肯定是最短的

    for (int i = 1; i <= cows_sum; i++)
    {
        for (int i = 1; i + 1 <= cows_sum; i++)
            if (dist[i + 1] < MAX)//差分约束方程d[i+1]>=d[i]
                dist[i] = min(dist[i], dist[i + 1]);
        for (int i = 0; i < ML; i++)//差分约束方程d[AL]+DL>=d[BL]
            if (dist[L_Set[i].A] < MAX)
                dist[L_Set[i].B] = min(dist[L_Set[i].B], dist[L_Set[i].A] + L_Set[i].cost);
        for (int i = 0; i < MD; i++)//差分约束方程d[BD]-DD>=d[AD]
            if (dist[M_Set[i].B] < MAX)
                dist[M_Set[i].A] = min(dist[M_Set[i].A], dist[M_Set[i].B] - M_Set[i].cost);
    }

    int ans = dist[cows_sum];
    if (dist[1] < 0)
        printf("-1\n");
    else if (dist[cows_sum] == MAX)
        printf("-2\n");
    else printf("%d\n", ans);
}

 

SPFA:

#include <iostream>
#include <functional>
#include <algorithm>
#include <queue>
#define MAX 0x7f7f7f7f

using namespace std;

typedef int Position;
typedef struct least_
{
    int next;
    Position to;
    int cost;
}Edge_Set;

static Edge_Set edge[2000010];//存边
static Position Head[1005];
static int dist[1005];
static int out[1005];//记录出去多少次
static bool used[1005];//记录是否在队内

void SPFA(const int, const int);

int main(void)
{
    int cows_sum, ML, MD, i, cost, edge_sum;
    Position from, to;
    while (~scanf("%d%d%d", &cows_sum, &ML, &MD))
    {
        memset(Head, -1, sizeof(Head)); memset(dist, 0x7f, sizeof(dist)); memset(used, 0, sizeof(used)); memset(out, 0, sizeof(out));
        edge_sum = 0;
        //读入邻接表
        for (i = 0; i < ML; i++)//d[BL]-d[AL]<=DL->->->d[AL]+DL>=d[BL]
        {
            scanf("%d%d%d", &from, &to, &cost);//因为编号是有序的，所以只用储存单向边就可以了
            edge[edge_sum].next = Head[from]; edge[edge_sum].to = to; edge[edge_sum].cost = cost;
            Head[from] = edge_sum++;
        }
        for (i = 0; i < MD; i++)//d[BL]-d[AL]>=DL->->->d[BD]-DD>=d[AD]
        {
            scanf("%d%d%d", &from, &to, &cost);
            edge[edge_sum].next = Head[to]; edge[edge_sum].to = from; edge[edge_sum].cost = -cost;
            Head[to] = edge_sum++;
        }
        for (i = 1; i + 1 <= cows_sum; i++)//d[i+1]+0>=d[i]
        {
            edge[edge_sum].next = Head[i + 1]; edge[edge_sum].to = i; edge[edge_sum].cost = 0;
            Head[i + 1] = edge_sum++;
        }
        SPFA(cows_sum, edge_sum);
    }
    return 0;
}

void SPFA(const int cows_sum, const int edge_sum)//这次用STL玩玩
{
    Position out_pos, to;
    queue<Position>que;
    que.push(1); dist[1] = 0; used[1] = 1;

    while (!que.empty())
    {
        out_pos = que.front(); que.pop();
        used[out_pos] = 0;//出队了就标记为0
        out[out_pos]++;
        if (out[out_pos] > cows_sum)
        {
            printf("-1\n");
            return;
        }
        for (int k = Head[out_pos]; k != -1; k = edge[k].next)
        {
            to = edge[k].to;
            if (dist[to] > dist[out_pos] + edge[k].cost)
            {
                dist[to] = dist[out_pos] + edge[k].cost;
                if (!used[to])
                {
                    used[to] = 1;
                    que.push(to);
                }
            }
        }
    }
    if (dist[cows_sum] == MAX)
        printf("-2\n");
    else
        printf("%d\n", dist[cows_sum]);
}