最短路之差分约束

原创于 2020-04-25 13:10:20 发布 · 314 阅读

0 ·

CC 4.0 BY-SA版权

最短路专栏收录该内容

16 篇文章

订阅专栏

对于差分约束的题目，重于挖掘题目暗含的约束条件, 当图存在负环时无解

1.最大化xn-x1 正常建边，跑最短路

2.最小化xn-x1 反向建边，跑最长路

两类题型：

1.明显给出差分约束关系

2.区间类型的查分约束，需要进行转换，一般考虑前缀和

3.都需要挖掘隐藏的查分约束信息，一般考虑，差值大于等于0，或者某两个值相等

//#define LOCAL
#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define p_queue priority_queue

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}
//前向星
int n, m, l;
int head[50005], cnt;
struct e{
    int t, next;
    int w;
}edge[100005];
void add(int f, int t, int w)
{
    edge[cnt].t = t;
    edge[cnt].w = w;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
//spfa
int dis[50005], vis[50005], times[50005];
bool spfa(int root)
{
    mem(vis,0);
    queue <int> q;
    dis[root] = 0;
    vis[root] = 1;
    q.push(root);
    while(!q.empty())
    {
        int no = q.front();
        q.pop();
        vis[no] = 0;
        for(int i = head[no] ; i != -1; i = edge[i].next)
        {
            int v = edge[i].t, w = edge[i].w;
            if(dis[v] > dis[no] + w)
            {
                dis[v] = dis[no] + w;
                times[v] = times[no] + 1;
                if(times[v] == n)
                    return true;
                if(!vis[v])
                {
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
    return false;
}
int ans;
int main(void)
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("odata.out", "w", stdout);
#endif
    mem(head,-1);
    cnt = 0;
    int w, u, v;
    scanf("%d %d %d", &n, &m, &l);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d %d %d", &u, &v, &w);
        add(u, v, w);
    }
    for(int i = 1 ; i <= l ; i ++)
    {
        scanf("%d %d %d", &u, &v, &w);
        add(v, u, -w);
    }
    for(int i = 2 ; i <= n ; i ++)
        add(i,i-1,0);
    mem(dis,INF);
    for(int i = 1 ; i <= n ; i ++)
    {
        if(dis[i] == INF)
        {
            if(spfa(i)) {
                cout << "-1" << endl;
                return 0;
            }
            if(i == 1)
            {
                if(dis[n] == INF)
                    ans = -2;
                else
                    ans = dis[n];
            }
        }
    }
    cout<<ans<<endl;
}
/*
1 2 0
1 3 2
1 4 1
1 5 0
2 3 1
2 4 0
2 5 1
3 4 0
3 5 0
4 5 0
*/

//#define LOCAL
#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define p_queue priority_queue

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}
//前向星
int n, m;
int head[200005], cnt, ohead[200005], ocnt;
struct e{
    int t, next;
    int w;
}edge[400005],oedge[400005];
void add(int f, int t, int w)
{
    edge[cnt].t = t;
    edge[cnt].w = w;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
void oadd(int f, int t, int w)
{
    oedge[ocnt].t = t;
    oedge[ocnt].w = w;
    oedge[ocnt].next = ohead[f];
    ohead[f] = ocnt ++;
}
//spfa
ll dis[200005], vis[200005], times[200005];
void spfa(int root)
{
    mem(vis,0);
    queue <int> q;
    vis[root] = 1;
    dis[root] = 0;
    q.push(root);
    while(!q.empty())
    {
        int no = q.front();
        q.pop();
        vis[no] = 0;
        for(int i = ohead[no] ; i != -1; i = oedge[i].next)
        {
            int v = oedge[i].t, w = oedge[i].w;
            if(dis[v] < dis[no] + w)
            {
                dis[v] = dis[no] + w;
                times[v] = times[no] + 1;
                if(!vis[v])
                {
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
}
//tarjan
int ti , tot;
int dfn[200005] , low[200005], st[200005], scc[200005], type = 0;
void tarjan(int u)
{
    dfn[u] = low[u] = ++ ti;
    st[++ tot] = u;
    vis[u] = 1;
    for(int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        if(!dfn[edge[i].t])
        {
            tarjan(edge[i].t);
            low[u] = min(low[u],low[edge[i].t]);
        }
        else if(vis[edge[i].t])
            low[u] = min(low[u],dfn[edge[i].t]);
    }
    if(low[u] == dfn[u])
    {
        type ++;
        do{
            scc[st[tot]] = type;
            vis[st[tot]] = 0;
            tot --;
        }while(u != st[tot+1]);
    }
    return ;
}
int temp = 0;
map <int,int> ma;
int Size[200005];
void judge()
{
    for(int i = 1 ; i <= n ; i ++)
    {
        for(int j = head[i] ; j != -1 ; j = edge[j].next)
        {
            int v = edge[j].t , w = edge[j].w;
            if(scc[v] == scc[i]) {
                ma[scc[v]] += w;
                if(ma[scc[v]]) {
                    temp = 1;
                    break;
                }
            }
            else
                oadd(scc[i],scc[v],w);
        }
    }
}
ll ans;
int main(void)
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("odata.out", "w", stdout);
#endif
    mem(head,-1);
    mem(ohead,-1);
    cnt = ocnt = 0;
    int u, v, x;
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d %d %d", &x, &u, &v);
        if (x == 1)
            add(u, v, 0), add(v, u, 0);
        else if(x == 2)
            add(u,v,1);
        else if(x == 3)
            add(v,u,0);
        else if(x == 4)
            add(v,u,1);
        else
            add(u,v,0);
    }
    //tarjan找环
    for(int i = 1 ; i <= n ; i ++)
        if(!dfn[i])
            tarjan(i);
    //统计环内节点数
    for(int i = 1 ; i <= n ; i ++)
        Size[scc[i]] ++;
    //构图DAG
    judge();
    //正环无解
    if(temp == 1)
    {
        cout<<"-1"<<endl;
        return 0;
    }
    //统计结果
    for(int i = 1 ; i <= type ; i ++)
        oadd(0,i,0);
    mem(dis,-1);
    spfa(0);
    for(int i = 0 ; i <= type ; i ++)
        ans += dis[i]*Size[i];
    cout<<ans+n<<endl;

}
/*
1 2 0
2 1 0
3 2 1
1 4 1
5 4 0
4 5 0
3 5 1


1 2 0
2 1 0
3 2 1
1 4 1
5 4 0
4 5 0
3 5 1
1 5 1
 */