0512棋盘游戏

Bellman-Ford算法

注意：不能存在负权回路，因为

对于“2”节点，每次经过那个负权环，长度就-1，转无穷多圈后，dist[2]=-∞，导致dist[i]（2<i<=6）都为-∞。

Bellman-Ford算法思想：

k次迭代后的意义： 从1号点，经过不超过k条边，走到每个点的最短距离。

时间复杂度

O(nm) n次迭代 ，m条边

Dijstra算法要求 图中一定不能存在负权边

853.有边数限制的最短路

给定一个 n个点 m条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1号点到 n号点的最多经过 k条边的最短距离，如果无法从 11号点走到 n号点，输出 impossible。

注意：图中可能 存在负权回路 。

输入格式

第一行包含三个整数 n,m,k。

接下来 m行，每行包含三个整数 x,y,z，表示存在一条从点 x到点 y的有向边，边长为 z。

点的编号为 1∼n。

输出格式

输出一个整数，表示从 1号点到 n号点的最多经过 k条边的最短距离。

如果不存在满足条件的路径，则输出 impossible。

数据范围

1≤n,k≤500,
1≤m≤10000,
1≤x,y≤n，
任意边长的绝对值不超过 10000。

输入样例：

3 3 1
1 2 1
2 3 1
1 3 3

输出样例：

3

Code

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=510,M=10010;
int dist[N],backup[N];
struct Edge{
    int a,b,w;
}edges[M];
int n,m,k;
int bellman_ford()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<k;i++)
    {
        memcpy(backup,dist,sizeof dist);//backup作用为备份dist 
        for(int j=0;j<m;j++)
        {
            int a=edges[j].a,b=edges[j].b,w=edges[j].w;
            dist[b]=min(dist[b],backup[a]+w);//使用上一次迭代的结果去更新 否则可能会出现边串联的情况
        }
    }
    if(dist[n]>0x3f3f3f3f/2)return 0x3f3f3f3f;
    return dist[n];
}
int main()
{
    cin>>n>>m>>k;
    for(int i=0;i<m;i++)
    {
        int a,b,w;
        cin>>a>>b>>w;
        edges[i]={a,b,w};
    }
    int ans=bellman_ford();
    if(ans==0x3f3f3f3f)cout<<"impossible"<<endl;
    else cout<<ans<<endl;
    return 0;
}

851.spfa求最短路

给定一个 n个点 m条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出 1号点到 n号点的最短距离，如果无法从 1号点走到 n号点，则输出 impossible。

数据保证不存在负权回路。

输入格式

第一行包含整数 n和 m。

接下来 m行每行包含三个整数 x,y,z，表示存在一条从点 x到点 y的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 n号点的最短距离。

如果路径不存在，则输出 impossible。

数据范围

1≤n,m≤10⁵,
图中涉及边长绝对值均不超过 10000。

输入样例：

3 3
1 2 5
2 3 -3
1 3 4

输出样例：

2

分析

spfa算法是对bellman-ford算法的优化

for(int i=0;i<k;i++)
    {
        for(int j=0;j<m;j++)
        {
            int a=edges[j].a,b=edges[j].b,w=edges[j].w;
            dist[b]=min(dist[b],backup[a]+w);//只有上一次迭代dist[a]变小了，dist[b]才有可能会变小
          //spfa正是基于这点进行优化的 用宽搜去做优化~
        }
    }

Code

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int N=100010;
int n,m;
int h[N],e[N],ne[N],w[N],idx;
int dist[N];
bool st[N];//表示点是否在队列中
void add(int a,int b,int c)
{
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}
int spfa()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    queue<int> q;
    q.push(1);
    st[1]=true;
    while(q.size())
    {
        int t=q.front();
        q.pop();
        st[t]=false;
        for(int i=h[t];i!=-1;i=ne[i])
        { 
            int j=e[i];
            if(dist[j]>dist[t]+w[i])
            {
                dist[j]=dist[t]+w[i];
                if(!st[j])
                {
                    st[j]=true;
                    q.push(j);
                }
            }
        }
    }
    return dist[n];
}
int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    int t=spfa();
    if(t==0x3f3f3f3f)cout<<"impossible"<<endl;
    else cout<<t<<endl;
    return 0;
}

3480.棋盘游戏

有一个 6×6的棋盘，棋盘的每个位置上都有一个数值，现在有一个起始位置和终止位置，请找出一个从起始位置到终止位置代价最小的路径：

1. 只能沿上下左右四个方向移动。
2. 总代价是每走一步的代价之和。
3. 每步从 (a,b)到 (c,d)的代价是 (c,d)上的数值与其在 (a,b)上的状态的乘积。
4. 初始状态为 1，每走一步，状态按如下公式变化：(走这步的代价mod4)+1。

输入格式

每组数据一开始为 6×6的矩阵，然后四个整数表示起始坐标和终止坐标。

横纵坐标均从 0开始，矩阵的左上角为 (0,0)，右下角为 (5,5)。

输出格式

输出最小代价。

数据范围

矩阵内数值的取值范围 [1,10]。

输入样例：

1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
0 0 5 5

输出样例:

23

分析

其实没太懂，闫老师讲循序渐进的思路讲的挺好的，只是我完全没能理解，是因为我前面对于spfa的理解还不够深入。等把图论熟练了，再反过来看这道题吧！

Code

#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=6;
int dist[N][N][5],w[N][N];
bool st[N][N][5];
int sx,sy,tx,ty;
struct Node{
    int x,y,s;
};
int spfa()
{
    int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
    memset(dist,0x3f,sizeof dist);
    queue<struct Node> q;
    dist[sx][sy][1]=0;
    q.push({sx,sy,1});
    st[sx][sy][0]=true;
    while(q.size())
    {
        auto t=q.front();
        q.pop();
        st[t.x][t.y][t.s]=false;
        for(int i=0;i<4;i++)
        {
            int x=t.x+dx[i],y=t.y+dy[i];
            if(x>=N||x<0||y>=N||y<0)
            continue;
            int cost=t.s*w[x][y];
            int s=cost%4+1;
            if(dist[x][y][s]>dist[t.x][t.y][t.s]+cost)
            {
                dist[x][y][s]=dist[t.x][t.y][t.s]+cost;
                if(!st[x][y][s])
                {
                    q.push({x,y,s});
                    st[x][y][s]=true;
                }
            }
        }
    }
    int ans=0x3f3f3f3f;
    for(int i=1;i<=4;i++)
    ans=min(ans,dist[tx][ty][i]);
    return ans;
}
int main()
{
    for(int i=0;i<6;i++)
        for(int j=0;j<6;j++)
            cin>>w[i][j];
    cin>>sx>>sy>>tx>>ty;
    cout<<spfa()<<endl;
    return 0;
}