ccf题目总结

题目就不粘贴了
思路：用sum，ans数组分别存储1号结点到每个节点连续走小路的路程，以及1号结点到每个结点的最终疲惫值，疲惫值的计算为如果当前走的是小路，则更新疲惫值以及累计走的小路总和，ans的更新规则为上一结点的疲惫值减去之前走小路累计的疲惫值，然后再加上当前走小路的疲惫值，即 ans[ne]=ans[nn]-sum[nn]sum[nn]+(sum[nn]+next.v)(sum[nn]+next.v)，sum更新为当前走小路所累积的路程，即sum[ne]=sum[nn]+next.v,如果走大路，则sum清空为0；ans更新为ans[ne]=ans[nn]+next.v, next.v为nn号结点与ne号结点之间的路径长度。
注意点：
1.sum，ans用长整型数组存储，虽然答案不会超过整形范围，但是在 ans[ne]=ans[nn]-sum[nn]sum[nn]+(sum[nn]+next.v)(sum[nn]+next.v)计算过程会超过整形范围；
2.虽然ccf提供的测试数据不用考虑通过不同路径到达同一结点疲惫值相同的情况，但是根据题目意思要考虑（虽然你不考虑也能得满分，但是下次就没有这么好运了）我的代码考略了这种情况，即更新sum时选择较小的sum。
代码：
dijkstra算法：

#include<bits/stdc++.h>
using namespace std;
const int N=5e2+5;
const int  M=1e5+5;
#define INF 0x7fffffff
typedef long long ll;
int n,m;
struct eNode
{
    int t;
    int to;
    int v;
};
ll ans[N];
ll sum[N];
vector<eNode> g[N];
void read()
{
    cin>>n>>m;
    int t,f,to,value;
    for(int i=0; i<m; i++)
    {
        cin>>t>>f>>to>>value;
        g[f].push_back((eNode)
        {
            t,to,value
        } );
        g[to].push_back((eNode)
        {
            t,f,value
        } );
    }
}
void dijkstra(int s)
{
    queue<int> q;
    for(int i=1; i<=n; i++)
    {
        ans[i]=INF;
        sum[i]=INF;
    }
    ans[s]=0;
    sum[s]=0;
    for(int k=1; k<=n; k++)
    {
           q.push(k);
            while(!q.empty())
            {
                int nn=q.front();
                q.pop();
                for(int i=0; i<g[nn].size(); i++)
                {
                    eNode next=g[nn][i];
                    int ne=g[nn][i].to;
                    if(next.t==1)
                    {
                        if(ans[nn]-sum[nn]*sum[nn]+(sum[nn]+next.v)*(sum[nn]+next.v) <ans[ne])
                        {
                            ans[ne]=ans[nn]-sum[nn]*sum[nn]+(sum[nn]+next.v)*(sum[nn]+next.v);
                            sum[ne]=sum[nn]+next.v;
                            q.push(ne);
                        }

                        else if(ans[nn]-sum[nn]*sum[nn]+(sum[nn]+next.v)*(sum[nn]+next.v)==ans[ne])
                        {
                            if(sum[nn]+next.v<sum[ne])
                            {
                                sum[ne]=sum[nn]+next.v;
                                q.push(ne);
                            }

                        }

                    }
                    else if(next.t==0)
                    {

                        if(ans[nn]+next.v<=ans[ne])
                        {
                            ans[ne]=ans[nn]+next.v;
                            sum[ne]=0;
                            q.push(ne);
                        }
                    }
                }

            }

    }
    cout<<ans[n];
}
void solve()
{
    dijkstra(1);
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    read();
    solve();
}

spfa算法：

#include<bits/stdc++.h>
using namespace std;
const int N=5e2+5;
const int  M=1e5+5;
#define INF 0x7fffffff
typedef long long ll;
int n,m;
struct eNode
{
    int t;
    int to;
    int v;
};
bool vis[N];
ll ans[N];
ll sum[N];
vector<eNode> g[N];
void read()
{
    cin>>n>>m;
    int t,f,to,value;
    for(int i=0; i<m; i++)
    {
        cin>>t>>f>>to>>value;
        g[f].push_back((eNode)
        {
            t,to,value
        } );
        g[to].push_back((eNode)
        {
            t,f,value
        } );
    }
}
void spafa()
{
    queue<eNode> q;
    for(int i=2; i<=n; i++)
    {
        ans[i]=INF;
        sum[i]=INF;
    }
    q.push((eNode)
    {
        0,1,0
    });
    ans[1]=0;
    vis[1]=1;
    sum[1]=0;
    while(!q.empty())
    {
        eNode now=q.front();
        q.pop();
        int nn=now.to;
        vis[nn]=0;
        for(int i=0; i<g[nn].size(); i++)
        {
            eNode next=g[nn][i];
            int ne=g[nn][i].to;
            if(next.t==1)
            {
                if(ans[nn]-sum[nn]*sum[nn]+(sum[nn]+next.v)*(sum[nn]+next.v) <ans[ne])
                {
                    ans[ne]=ans[nn]-sum[nn]*sum[nn]+(sum[nn]+next.v)*(sum[nn]+next.v);
                    sum[ne]=sum[nn]+next.v;
                    if(!vis[ne])
                    {
                        q.push(next);
                        vis[ne]=1;
                    }

                }
                else if(ans[nn]-sum[nn]*sum[nn]+(sum[nn]+next.v)*(sum[nn]+next.v)==ans[ne])
                {
                    if(sum[nn]+next.v<sum[ne])
                        sum[ne]=sum[nn]+next.v;
                }
            }
            else if(next.t==0)
            {

                if(ans[nn]+next.v<ans[ne])
                {
                    ans[ne]=ans[nn]+next.v;
                    sum[ne]=0;
                    if(!vis[ne])
                    {
                        q.push(next);
                        vis[ne]=1;
                    }
                }
                else if(ans[nn]+next.v==ans[ne])
                {

                        sum[ne]=0;
                }
            }
        }

    }
    cout<<ans[n];
}
void solve(){
  spafa();
}
int main()
{
  ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
  read();
  solve();
}

https://blog.csdn.net/wingrez/article/details/85111975?