第七讲：图论-CSDN博客

本文链接：https://blog.csdn.net/2503_90403450/article/details/145729827

1.Stockbroker Grapevine

求这张关系图中传播最快的起点，就需要任意两点的最短路，用Floyd算法，然后枚举每个点作为起点的最大传播时间，进行比较最小的就是所求点。

#include <iostream>
using namespace std;
const int MAXN = 1e3 + 5;
int f[MAXN][MAXN],k,o,p,n,m,ans,tool,t;
int main()
{
   cin >> n;
   while (n)
   {
       for (int i = 1; i <= n; i++)
       {
           for (int j = 1; j <= n; j++)
           {
               if (i != j)
                   f[i][j] = MAXN;
           }
       }
       for (int i = 1; i <= n; i++)
       {
           f[i][i] = 0;
           cin >> m;
           for (int j = 1; j <= m; j++)
           {
               int other;
               cin >> other;
               cin >> f[i][other];
           }
       }
       t = 10000000000;
       for (int k = 1; k <= n; k++)
       {
           for (int i = 1; i <= n; i++)
           {
               for (int j = 1; j <= n; j++)
               {
                   f[i][j] = min(f[i][k] + f[k][j], f[i][j]);
               }
           }
       }
       for (int i = 1; i <= n; i++)
       {
           tool = 0;
           for (int j = 1; j <= n; j++)
           {
               tool = max(tool, f[i][j]);
           }
           if (tool < t)
           {
               t = tool;
               ans = i;
           }
       }
       if (t == 10000000000)
           cout << "disjoint" << endl;
       else
           cout << ans << ' ' << t << endl;
       cin>>n;
   }
}

2.树的直径

求树上的最大路径长，枚举每个点的最大路径长，就是它的树长中最大的两个之和，他的最大的树长就是最大子树长+1，最后就得到直径。

#include <iostream>
using namespace std;
const int MAXN = 1e5 + 5;
struct
{
   int father;
   int r1, r2;
}node[MAXN];
int n, u, v,ans=0;
int main()
{
   cin >> n;
   for (int i = 1; i <= n-1; i++)
   {
       cin >> u >> v;
       node[v].father = u;
   }
   for (int i = n; i >= 1; i--)
   {
       if (node[node[i].father].r1 < node[i].r1 + 1)
       {
           node[node[i].father].r2 = node[node[i].father].r1;
           node[node[i].father].r1 = node[i].r1 + 1;
       }
       else
       {
           node[node[i].father].r2 = max(node[node[i].father].r2, node[i].r1 + 1);
       }
   }
   for (int i = 1; i <= n; i++)
   {
       ans = max(ans, node[i].r1 + node[i].r2 );
   }
   cout << ans;
}

3.Invitation Cards

题目要求我们求出从起始站到其他所有站点的最短路，我们可以用dijkstra算法来计算，但还要求我们求出返回的最短路径，即从所有站点到起始站的最短路，事实上我们可以反向建图，把路径的起点与终点调换，就转化成求起始站到其他站的最短路，再用一次dijkstra算法来算。

#include <iostream>
#include <queue>
using namespace std;
const int MAXN = 1e6 + 6;
int head[MAXN], rhead[MAXN], len, rlen,d[MAXN],ans;
bool vis[MAXN];
struct
{
   int v, w, next;
}e[MAXN],re[MAXN];
struct Node
{
   int v, d;
   Node(int v,int d):v(v),d(d){}
   bool operator <(const Node &w)const
   {
       return d > w.d;
   }
};
void add(int u, int v, int w)
{
   e[len].v = v;
   e[len].next = head[u];
   e[len].w = w;
   head[u] = len++;
}
void radd(int u, int v, int w)
{
   re[rlen].v = v;
   re[rlen].next = rhead[u];
   re[rlen].w = w;
   rhead[u] = rlen++;
}
void dijkstra(int u)
{
   memset(d, 0x3f, sizeof(d));
   memset(vis, false, sizeof(vis));
   d[u] = 0;
   priority_queue<Node>ac;
   ac.push(Node(u, d[u]));
   while (!ac.empty())
   {
       u = ac.top().v;
       ac.pop();
       if (vis[u])
           continue;
       vis[u] = true;
       for (int i = head[u]; i; i = e[i].next)
       {
           int v = e[i].v;
           int w = e[i].w;
           if (!vis[v] && d[v] > d[u] + w)
           {
               d[v] = d[u] + w;
               ac.push(Node(v, d[v]));
           }
       }
   }
}
int main()
{
   int n,p,q;
   cin >> n;
   for (int some = 1; some <= n; some++)
   {
       cin >> p >> q;
       memset(head, 0, sizeof(head));
       memset(rhead, 0, sizeof(rhead));
       ans = 0, len = 1, rlen = 1;
       int u, v, w;
       for (int i = 1; i <= q; i++)
       {
           cin >> u >> v >> w;
           add(u, v, w);
           radd(v, u, w);
       }
       dijkstra(1);
       for (int i = 1; i <= p; i++)
       {
           ans += d[i];
       }
       memcpy(head, rhead, sizeof(rhead));
       memcpy(e, re, sizeof(re));
       dijkstra(1);
       for (int i = 1; i <= p; i++)
       {
           ans += d[i];
       }
       cout << ans << endl;
   }
}

4.战略游戏

首先我们看题目可以知道士兵在子节点站岗不如到父节点站岗，因为如果父节点没有站岗，其所有子节点都要有士兵，从最小的节点开始遍历。但是这种方法无法处理既没有子节点也没有父节点的孤儿节点，要把它找出来在放士兵。

#include <iostream>
using namespace std;
const int MAXN = 1505;
struct
{
   int father,son;
   bool soldier;
}node[MAXN];
int n, i, k, ans = 0,son;
int main()
{
   cin >> n;
   node[0].father = -1;
   for (int j = 1; j <= n; j++)
   {
       cin >> i>> k;
       node[i].son = k;
       for (int op = 1; op <= k; op++)
       {
           cin >> son;
           node[son].father = i;
       }
   }
   for (int j = n - 1; j >= 1; j--)
   {
       if (node[j].soldier==false)
       {
           node[node[j].father].soldier = true;
       }
   }
   if (node[0].soldier == false)
   {
       for (int j = 1; j <= n-1; j++)
       {
           if (node[j].father == 0&&node[j].soldier==false)
           {
               node[0].soldier = true;
           }
       }
       if(node[0].son==0)
           node[0].soldier = true;
   }
   for (int j = n - 1; j >= 0; j--)
   {
       if (node[j].soldier)
       {
           ans++;
       }
   }
   cout << ans;
}