flyod

最开始看错数据了没看到Q = 100 是50%的数据以为跑q遍floyd能过，结果只有30，其他全t

1、要注意题目中的条件，挖掘一些性质

var code = “92ce4972-7e0f-4a6f-9f3a-4efef328be45”

2、本题的另一个关键的是要对floyd的过程原理比较熟悉，floyd一共有三重循环，第一重循环相当于枚举的决策，也就是能从那个点转移过来，k就是这个中转站，另外两重循环是枚举的状态

3、我们观察到每个村庄的重建时间是递增的，并且询问的时间也是递增或保持不变，所以我们可以在读入每个询问的时间时，看一下是否存在中转站，在这个时间已经建好，并且可以去更新其他点，我们找到所以这样的点去更新，然后cur不用回去，因为询问的时间也是递增的，只需要在读入下一个询问后，查看是否有新的中转点可以去更新其他点即可。

4、经过上面的分析我们可以知道我们只需要跑一遍floyd即可，因为只有满足的中转点才会被用，时间复杂度为O(n^3）

附上floyd的板子

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 210, INF = 1e9;

int n, m, Q;

int d[N][N];

void Floyd()
{
    for(int k = 1; k <= n; k ++)
        for(int i = 1; i <= n; i ++)
         for(int j = 1; j <= n; j ++)
            //要取一下最小值这个写的时候老是忘记
            d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

int main()
{
    cin >> n >> m >> Q;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= n; j ++)
            if(i == j)  d[i][j] = 0;
            else    d[i][j] = INF;

    for(int i = 0; i < m; i ++)
    {
        int a, b, w; cin >> a >> b >> w;
        d[a][b] = min(d[a][b], w);
     }

    Floyd();

    while(Q --)
    {
        int a, b; cin >> a >> b;
        if(d[a][b] > INF / 2)   puts("impossible");
        else    cout << d[a][b]<<endl;;
    }

    return 0;
}

---

灾后重建

题目背景

B 地区在地震过后，所有村庄都造成了一定的损毁，而这场地震却没对公路造成什么影响。但是在村庄重建好之前，所有与未重建完成的村庄的公路均无法通车。换句话说，只有连接着两个重建完成的村庄的公路才能通车，只能到达重建完成的村庄。

题目描述

给出 B 地区的村庄数

N

N

N，村庄编号从

0

0

0 到

N

−

1

N-1

N−1，和所有

M

M

M 条公路的长度，公路是双向的。并给出第

i

i

i 个村庄重建完成的时间

t

i

t_i

ti​，你可以认为是同时开始重建并在第

t

i

t_i

ti​ 天重建完成，并且在当天即可通车。若

t

i

t_i

ti​ 为

0

0

0 则说明地震未对此地区造成损坏，一开始就可以通车。之后有

Q

Q

Q 个询问

(

x

,

y

,

t

)

(x,y,t)

(x,y,t)，对于每个询问你要回答在第

t

t

t 天，从村庄

x

x

x 到村庄

y

y

y 的最短路径长度为多少。如果无法找到从

x

x

x 村庄到

y

y

y 村庄的路径，经过若干个已重建完成的村庄，或者村庄

x

x

x 或村庄

y

y

y 在第

t

t

t 天仍未重建完成，则需要返回 -1。

输入格式

第一行包含两个正整数

N

,

M

N,M

N,M，表示了村庄的数目与公路的数量。

第二行包含

N

N

N个非负整数

t

0

,

t

1

,

…

,

t

N

−

1

t_0, t_1,…, t_{N-1}

t0​,t1​,…,tN−1​，表示了每个村庄重建完成的时间，数据保证了

t

0

≤

t

1

≤

…

≤

t

N

−

1

t_0 ≤ t_1 ≤ … ≤ t_{N-1}

t0​≤t1​≤…≤tN−1​。

接下来

M

M

M行，每行

3

3

3个非负整数

i

,

j

,

w

i, j, w

i,j,w，

w

w

w为不超过

10000

10000

10000的正整数，表示了有一条连接村庄

i

i

i与村庄

j

j

j的道路，长度为

w

w

w，保证

i

≠

j

i≠j

i=j，且对于任意一对村庄只会存在一条道路。

接下来一行也就是

M

+

3

M+3

M+3行包含一个正整数

Q

Q

Q，表示

Q

Q

Q个询问。

接下来

Q

Q

Q行，每行

3

3

3个非负整数

x

,

y

,

t

x, y, t

x,y,t，询问在第

t

t

t天，从村庄

x

x

x到村庄

y

y

y的最短路径长度为多少，数据保证了

t

t

t是不下降的。

输出格式

共

Q

Q

Q行，对每一个询问

(

x

,

y

,

t

)

(x, y, t)

(x,y,t)输出对应的答案，即在第

t

t

t天，从村庄

x

x

x到村庄

y

y

y的最短路径长度为多少。如果在第t天无法找到从

x

x

x村庄到

y

y

y村庄的路径，经过若干个已重建完成的村庄，或者村庄x或村庄

y

y

y在第

t

t

t天仍未修复完成，则输出

−

1

-1

−1。

样例 #1

样例输入 #1

4 5
1 2 3 4
0 2 1
2 3 1
3 1 2
2 1 4
0 3 5
4
2 0 2
0 1 2
0 1 3
0 1 4

样例输出 #1

-1
-1
5
4

提示

对于

30

%

30\%

30%的数据，有

N

≤

50

N≤50

N≤50；

对于

30

%

30\%

30%的数据，有

t

i

=

0

t_i= 0

ti​=0，其中有

20

%

20\%

20%的数据有

t

i

=

0

t_i = 0

ti​=0且

N

>

50

N>50

N>50；

对于

50

%

50\%

50%的数据，有

Q

≤

100

Q≤100

Q≤100；

对于

100

%

100\%

100%的数据，有

N

≤

200

N≤200

N≤200，

M

≤

N

×

(

N

−

1

)

/

2

M≤N \times (N-1)/2

M≤N×(N−1)/2，

Q

≤

50000

Q≤50000

Q≤50000，所有输入数据涉及整数均不超过

100000

100000

100000。

#include <iostream>
#include <cstring>
using namespace std;
const int N = 210, INF = 2e9;

long long  d[N][N], a[N];
bool st[N];
int n, m;

inline void floyd(int k)
{
    for(int i = 0; i < n; ++ i)
        for(int j = 0; j < n; ++ j)
        if(d[i][j] > d[i][k] + d[k][j])
            d[i][j] = d[i][k] + d[k][j];

}

int main()
{
    // freopen("1.in.txt", "r", stdin);
    cin >> n >> m;
    for(int i = 0; i < n; ++ i) cin >> a[i];
    for(int i = 0; i < n; ++ i)
        for(int j = 0; j < n; ++ j)
        {
            if(i == j)  d[i][i] = 0;
            d[i][j] = INF;
        }

    for(int k = 0; k < m; ++ k)
    {
        int a, b ,c; cin >> a >> b >> c;
        d[a][b] = d[b][a] = c;
    }

    int q, cur = 0;cin >> q;
    while(q --)
    {
        int x, y, t; cin >> x >> y >> t;
        while(a[cur] <= t && cur < n)
        {
            floyd(cur);
            cur ++;
        }
        if(a[x] > t || a[y] > t || d[x][y] == INF)  cout << -1 << endl;
        else    cout << d[x][y] << endl;
    }
    return 0;
}