【2024.8.16】Traveller解题报告——图论基础

已于 2024-08-16 22:23:16 修改
阅读量337 收藏 5
点赞数 6
文章标签： 图论
于 2024-08-16 10:29:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/InfCraft/article/details/141248341
版权

文章目录

写在前面

前段时间做多校，感觉自己的基础不太好，之前学过的一些东西也都忘记了，想趁这个机会回来补一补基础，尤其是图论这一块。因此我打算回来做一些经典的图论算法题，“不积跬步，无以至千里”，还是从基础的开始，一步一步去挑战更难的题目。

HDU - 4081 Qin Shi Huang’s National Road System

题目大意

给你一张 n n n个点的二维平面图，每个点都有其坐标和点权（第 i i i个点的点权为 a i a_i ai​），要求一棵连接这 n n n个点的生成树，满足其中一条边连接的两个点的点权之和与除去这条边以外 n − 2 n-2 n−2条边的边权和的比值最大。在本题中边权即为两点之间的欧几里得距离。

数据范围： 3 ≤ n ≤ 1 0 3 3 \le n \le 10^3 3≤n≤103（题目说 n ≥ 2 n \ge 2 n≥2但 n n n显然不可能为2）， 1 ≤ a i ≤ 1 0 5 1 \le a_i \le 10^5 1≤ai​≤105。

解题思路

首先，我们称那条不算边权的边为魔法边。这道题其实一上来就应该想到去枚举最小生成树的每一条边。为什么这么说？因为最小生成树上的每一条边的边权都是最小的，如果最终的边除了魔法边外不在最小生成树上，那么其边权之和一定会大于最小生成树生成的边。最小生成树足够把 n n n个点连接起来。

那么答案就呼之欲出了。首先跑出最小生成树，然后枚举每条最小生成树上的边，去掉该条边，则图会被分割成两个不连通的树。这时分别用dfs找到这两棵树上点权最大的点，用魔法边连接这两个点，更新答案。时间复杂度为 O ( n 2 ) O(n^2) O(n2)，可以通过此题。

AC代码

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define pb push_back

#define Yes cout << "Yes\n"
#define No cout << "No\n"
#define YES cout << "YES\n"
#define NO cout << "NO\n"
#define ff first
#define ss second
#define fori(x,y) for(int i=x;i<=(int)(y);++i)
#define forj(x,y) for(int j=x;j<=(int)(y);++j)
#define fork(x,y) for(int k=x;k<=(int)(y);++k)

#define debug(x) cout << #x << " = " << x << endl

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

ll MOD = 998244353;
ll qpow(ll a,ll p) {ll res=1; while(p) {if (p&1) {res=res*a%MOD;} a=a*a%MOD; p>>=1;} return res;}

const int N = 1e3+7;

int x[N], y[N], arr[N];

double getdis(int i, int j) {
    return sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
}

vector<int> g[N];
set<pii> edge;
bool done[N];  // done[i] = true表示该点已经在MST中
double prim(int n) {
    int s=1;  // 从任意一个顶点开始
    fori(1, n) done[i] = false;  // 初始化
    priority_queue<pair<double,pii>, vector<pair<double,pii>>, greater<pair<double,pii>>> que;
    que.push({0, {s, 0}});
    int cnt = 0;  // 记录顶点个数而非边数！
    double ans = 0;  // 记录最小权值
    while (que.size()) {
        auto pi = que.top();
        int u = pi.second.first;
        que.pop();
        if (done[u]) continue;  // 判圈
        done[u] = true;
        ans += pi.first;
        cnt++;

        // addedge
        if (pi.second.second) {
            edge.insert({pi.second.second, u});
            g[pi.second.second].push_back(u);
            g[u].push_back(pi.second.second);
        }

        fori(1, n) {
            if (done[i]) continue;
            double dis = getdis(u, i);
            que.push({dis, {i, u}});
        }
    }
    return ans;
}

int ma = 0;
void dfs(int u, int fa) {
    if (arr[u]>arr[ma]) ma = u;
    for (auto v: g[u]) {
        if (v == fa) continue;
        dfs(v, u);
    }
}
void solve() {
	int n; scanf("%d", &n);
    edge.clear();
    fori(1, n) g[i].clear();
    fori(1, n) scanf("%d%d%d", x+i, y+i, arr+i);
    double res = prim(n);

    double ans = 0;
    for (auto pi: edge) {
        int u, v;
        dfs(pi.first, pi.second);
        u = ma; ma = 0;
        dfs(pi.second, pi.first);
        v = ma; ma = 0;
        ans = max(ans, 1.0*(arr[u]+arr[v])/(res-getdis(pi.first, pi.second)));
    }
    cout << ans << endl;
}

signed main() {
	IOS;
	int t; scanf("%d", &t);
    cout << fixed << setprecision(2);
	while (t--) {
		solve();
	}
	return 0;
}

HDU - 2874 Connections between cities

题目大意

给你一个 n n n个节点 m m m条边的森林和 q q q次询问，每次询问给出两个点 u u u， v v v，判断两个点是否连通，如果连通则输出其最短距离。

数据范围： 2 ≤ n ≤ 1 0 4 2 \le n \le 10^4 2≤n≤104， 1 ≤ m ≤ n − 1 1 \le m \le n-1 1≤m≤n−1， 1 ≤ q ≤ 1 0 6 1 \le q \le 10^6 1≤q≤106

解题思路

非常经典的求LCA的题目，只是需要判断是否连通即可。这个也好判断，如果两个点的LCA为0，那么就不连通。

时间复杂度 O ( n log ⁡ n + q log ⁡ n ) O(n\log n +q\log n) O(nlogn+qlogn)。

AC代码

#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define pb push_back
#define endl '\n'

#define Yes cout << "Yes\n"
#define No cout << "No\n"
#define YES cout << "YES\n"
#define NO cout << "NO\n"
#define ff first
#define ss second
#define fori(x,y) for(int i=x;i<=(int)(y);++i)
#define forj(x,y) for(int j=x;j<=(int)(y);++j)
#define fork(x,y) for(int k=x;k<=(int)(y);++k)

#define debug(x) cout << #x << " = " << x << endl

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

ll MOD = 998244353;
ll qpow(ll a,ll p) {ll res=1; while(p) {if (p&1) {res=res*a%MOD;} a=a*a%MOD; p>>=1;} return res;}

const int N = 1e4+7;
unordered_map<ll, ll> g[N];

bool vis[N];
int dep[N], father[N];

int go[N][20];
ll dis[N][20];

void dfs(int u, int fa) {
    if (vis[u]) return;
    vis[u] = true;
    father[u] = fa;
    dep[u] = dep[fa]+1;
    for (auto pi: g[u]) {
        if (pi.first == fa) continue;
        dfs(pi.first, u);
    }
}

ll getdis(int u, int v) {
    ll ans = 0;
    if (dep[u]<dep[v]) swap(u, v);
    for (int j=19;j>=0;--j) {
        if (dep[go[u][j]]>=dep[v]) {
            ans += dis[u][j];
            u = go[u][j];
        }
    }
    if (u == v) return ans;
    for (int j=19;j>=0;--j) {
        if (go[u][j] != go[v][j]) {
            ans += dis[u][j]+dis[v][j];
            u = go[u][j], v = go[v][j];
        }
    }
    ans += dis[u][0]+dis[v][0];
    if (go[u][0] == 0) return -1;
    return ans;
}

signed main() {
	IOS;
    int n, m, q;
    while (~scanf("%d%d%d", &n, &m, &q)) {
        fori(1, n) {
            vis[i] = false;
            g[i].clear();
        }
        while (m--) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            g[u].insert({v, w});
            g[v].insert({u, w});
        }
        fori(1, n) if (!vis[i]) dfs(i, 0);

        // void init
        fori(1, n) {
            go[i][0] = father[i];
            dis[i][0] = g[i][father[i]];
        }
        // fori(1, n) cout << father[i] << " ";
        // cout << endl;

        forj(1, 19) {
            fori(1, n) {
                go[i][j] = go[go[i][j-1]][j-1];
                dis[i][j] = dis[i][j-1]+dis[go[i][j-1]][j-1];
            }
        }

        while (q--) {
            int u, v; scanf("%d%d", &u, &v);
            ll res = getdis(u, v);
            if (res == -1) cout << "Not connected" << endl;
            else cout << res << endl;
        }
    }
	return 0;
}

HDU - 1217 Arbitrage

题目大意

你现在有一组货币的汇率，判断是否可以套汇。套汇的概念详见题面。

数据范围： 1 ≤ n ≤ 30 1 \le n \le 30 1≤n≤30。

解题思路

数据范围很小，可以想到floyd算法三层循环求传递闭包。但是在转移的过程中需要求的是边权的乘积而非和。

时间复杂度 O ( n 3 ) O(n^3) O(n3)。

AC代码

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define pb push_back

#define Yes cout << "Yes\n"
#define No cout << "No\n"
#define YES cout << "YES\n"
#define NO cout << "NO\n"
#define ff first
#define ss second
#define fori(x,y) for(int i=x;i<=(int)(y);++i)
#define forj(x,y) for(int j=x;j<=(int)(y);++j)
#define fork(x,y) for(int k=x;k<=(int)(y);++k)

#define debug(x) cout << #x << " = " << x << endl

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

ll MOD = 998244353;
ll qpow(ll a,ll p) {ll res=1; while(p) {if (p&1) {res=res*a%MOD;} a=a*a%MOD; p>>=1;} return res;}

const int N = 35;

double val[N][N];
signed main() {
	IOS;
	int n;
    int t = 0;
    while (1) {
        cin >> n;
        if (n == 0) break;
        t++;
        unordered_map<string,int> maps;
        fori(1, n) {
            string str; cin >> str;
            maps[str] = i;
        }
        fori(1, n) forj(1, n) val[i][j] = 0;

        int m; cin >> m;
        fori(1, m) {
            string str1, str2; double x;
            cin >> str1 >> x >> str2;
            val[maps[str1]][maps[str2]] = max(val[maps[str1]][maps[str2]], x);
        }

        fork(1, n) fori(1, n) forj(1, n) if (val[i][k]>0&&val[k][j]>0) val[i][j] = max(val[i][j], val[i][k]*val[k][j]);

        bool can = false;
        cout << "Case " << t << ": ";
        fori(1, n) if (val[i][i]>1+1e-10) {
            can = true;
            break;
        }
        if (can) Yes;
        else No;
        
    }
	return 0;
}

HDU - 2224 The shortest path

题目大意

给你 n n n个二维平面上的点，每个点有一个坐标 x i x_i xi​， y i y_i yi​，且保证若 i < j i<j i<j则 x i < x j x_i<x_j xi​<xj​，你需要从点1出发走到点 n n n，再从点 n n n走到点1，从1走到 n n n的期间你只能往编号大的点走，从 n n n走到1期间你只能往编号小的点走。来回的过程中必须经过每个点一次，不能重复经过某个点，也不能遗漏某个点。

数据范围： 2 ≤ n ≤ 200 2 \le n \le 200 2≤n≤200。

解题思路

上网搜了搜，发现这道题目叫做双调旅行商问题。解决这道题的思路是dp。由于路径的对称性，我们把这道题转化为：从点1出发，沿两条完全不同的路径（即没有点重合）走到 n n n的最短路径之和。

设 d p i , j dp_{i,j} dpi,j​表示从点1出发，第一条路径走到了点 i i i，第二条路径走到了点 j j j的最短路径长度。保证 i > j i>j i>j。显然，初始状态为 d p 2 , 1 = d i s ( 1 , 2 ) dp_{2, 1}=dis(1, 2) dp2,1​=dis(1,2)。接下来让我们看如何转移：

如果 j < i − 1 j<i-1 j<i−1，那么 d p i , j = d p i − 1 , j + d i s ( i , i − 1 ) dp_{i,j}=dp_{i-1, j}+dis(i, i-1) dpi,j​=dpi−1,j​+dis(i,i−1)，因为 i − 1 i-1 i−1走在前面，那么点 i − 1 i-1 i−1的下一个点必然是点 i i i，不能留空。

如果 j = = i − 1 j == i-1 j==i−1，那么这个时候就需要枚举了。枚举 1 ≤ k ≤ j − 1 1 \le k \le j-1 1≤k≤j−1，那么 d p i , j = min ⁡ ( d p j , k + d i s ( i , k ) ) dp_{i,j}=\min (dp_{j,k}+dis(i,k)) dpi,j​=min(dpj,k​+dis(i,k))。为什么？因为当 j j j走到 i − 1 i-1 i−1时， i i i只能从更远的 k < j k < j k<j转移过来。而 d p k , j dp_{k, j} dpk,j​和 d p j , k dp_{j, k} dpj,k​是等价的，因此直接从 d p j , k dp_{j,k} dpj,k​转移过来就可以了。

最后得到的答案为 d p n , n − 1 + d i s ( n − 1 , n ) dp_{n, n-1}+dis(n-1, n) dpn,n−1​+dis(n−1,n)。

时间复杂度为 O ( n 2 ) O(n^2) O(n2)。

AC代码

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define pb push_back

#define Yes cout << "Yes\n"
#define No cout << "No\n"
#define YES cout << "YES\n"
#define NO cout << "NO\n"
#define ff first
#define ss second
#define fori(x,y) for(int i=x;i<=(int)(y);++i)
#define forj(x,y) for(int j=x;j<=(int)(y);++j)
#define fork(x,y) for(int k=x;k<=(int)(y);++k)

#define debug(x) cout << #x << " = " << x << endl

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

ll MOD = 998244353;
ll qpow(ll a,ll p) {ll res=1; while(p) {if (p&1) {res=res*a%MOD;} a=a*a%MOD; p>>=1;} return res;}

const int N = 205;
pii pos[N];
double dis(int i, int j) {
    return sqrt((pos[i].first-pos[j].first)*(pos[i].first-pos[j].first)+(pos[i].second-pos[j].second)*(pos[i].second-pos[j].second));
}

double dp[N][N];
signed main() {
	IOS;
	int n;
    cout << fixed << setprecision(2);
    while (~scanf("%d", &n)) {
        fori(1, n) scanf("%d%d", &pos[i].first, &pos[i].second);
        
        dp[2][1] = dis(1, 2);
        fori(3, n) forj(1, i-1) {
            dp[i][j] = 1e20;
            if (j == i-1) {
                fork(1, j-1) {
                    dp[i][j] = min(dp[i][j], dp[j][k]+dis(k, i));
                }
            }
            else dp[i][j] = dp[i-1][j]+dis(i, i-1);
        }
        cout << (dp[n][n-1]+dis(n, n-1)) << endl;
    }
	return 0;
}

HDU - 1142 A Walk Through the Forest

题目大意

给你一张 n n n个点 m m m条边的无向图， 1 1 1为起点， 2 2 2为终点，从1号节点出发，当经过某个点 u u u时，如果存在一个点 v v v，使得 u , v u,v u,v相连，且 v v v到2的最短路径比 u u u到2的最短路径要短，那么就可以从 u u u走到 v v v。计算从1到2所有不同的路径数量。

数据范围： 2 ≤ n ≤ 1 0 3 2 \le n \le 10^3 2≤n≤103，边权 1 ≤ d ≤ 1 0 6 1 \le d \le 10^6 1≤d≤106。

解题思路

这道题是一道简单而又巧妙的题目。首先我们需要知道对于两个相邻节点 u u u和 v v v，怎么判断 u u u是否能够走向 v v v。很简单，从终点2跑一次单源最短路，然后就可以判断了。

那么如何计数？这里我的方法是dfs+记忆化搜索。我从节点1出发，逐一递归其邻接点，并将其所有邻接点的答案求和，更新该节点的dp值，再下一次搜索的时候直接使用该节点的dp值即可。

时间复杂度 O ( m log ⁡ n + n ) O(m\log n+n) O(mlogn+n)。

AC代码

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define pb push_back

#define Yes cout << "Yes\n"
#define No cout << "No\n"
#define YES cout << "YES\n"
#define NO cout << "NO\n"
#define ff first
#define ss second
#define fori(x,y) for(int i=x;i<=(int)(y);++i)
#define forj(x,y) for(int j=x;j<=(int)(y);++j)
#define fork(x,y) for(int k=x;k<=(int)(y);++k)

#define debug(x) cout << #x << " = " << x << endl

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

ll MOD = 998244353;
ll qpow(ll a,ll p) {ll res=1; while(p) {if (p&1) {res=res*a%MOD;} a=a*a%MOD; p>>=1;} return res;}

const int N = 1e3+7;

vector<pii> g[N];
int dist[N];
char vis[N];
void Dijkstra(int s, int n) {
	fori(1, n) dist[i] = -1, vis[i] = 0;
	dist[s] = 0;
	priority_queue<pii, vector<pii>, greater<pii>> pri;  // 优先队列
	pri.push({dist[s],s});
	while (pri.size()) {
		pii pi = pri.top();
		pri.pop();
		if (vis[pi.ss]) continue;
		vis[pi.ss] = 1;
		dist[pi.ss] = pi.ff;
		for (int i=0;i<g[pi.ss].size();++i) {
			pri.push({pi.ff+g[pi.ss][i].ss, g[pi.ss][i].ff});
		}
	}
}

int dp[N];
int dfs(int u) {
    if (dp[u]) return dp[u];
    if (u == 2) return 1;
    int res = 0;
    for (auto pi: g[u]) {
        if (dist[pi.first]>=dist[u]) continue;
        res += dfs(pi.first);
    }
    return (dp[u] = res);
}

signed main() {
	IOS;
	int n, m;
    while (~scanf("%d", &n)&&n) {
        scanf("%d", &m);
        fori(1, n) g[i].clear();
        while (m--) {
            int u,v,w;
            scanf("%d%d%d", &u, &v, &w);
            g[u].push_back({v, w});
            g[v].push_back({u, w});
        }
        Dijkstra(2, n);
        fori(1, n) dp[i] = 0;
        cout << dfs(1) << endl;
    }
	return 0;
}

HDU - 3639 Hawk-and-Chicken

题目大意

班里有 n n n个同学，全班要开一次班会选举班长，每个同学都可以“支持”其他同学，这种支持关系是具有传递性的，若同学A支持同学B，同学B支持同学C，那么同学A也会支持同学C。但自己不能支持自己。给定 m m m对支持关系，找到受到最多人支持的若干个同学，并输出这些同学的编号和支持他们的人数。

数据范围： 2 ≤ n ≤ 5 × 1 0 3 2 \le n \le 5\times 10^3 2≤n≤5×103， 1 ≤ m ≤ 3 × 1 0 4 1 \le m \le 3\times 10^4 1≤m≤3×104。

解题思路

看到这道题和样例，就可以想到：如果 k k k个同学互相支持，那么这 k k k个同学的支持数都为 k − 1 k-1 k−1。这里可以考虑使用Tarjan求强连通分量，然后缩点，得到一张DAG。接下来关键步骤来了：如何计算出支持数最多的同学呢？也就是如何在DAG上找到前驱数量最多的点。我当时想了半天，但是没有什么好的思路，因为无法用拓扑排序求出不重复的支持数。但考虑到 n n n的范围较小，或许可以通过减小常数通过 O ( n 2 ) O(n^2) O(n2)的算法。

考虑一张DAG，前驱数量最多的点只可能是出度为0的点。但直接在这张图上搜答案显然不太现实，因此我们考虑在缩点时建反图，然后求出后继数量最多的点。但这里只能用暴力了，从每一个入度为0的点开始跑dfs。复杂度是 O ( n 2 ) O(n^2) O(n2)，但常数 ≤ 1 4 \le \frac{1}{4} ≤41​，可以通过此题。最后把答案记录下来输出即可。

AC代码

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define pb push_back

#define Yes cout << "Yes\n"
#define No cout << "No\n"
#define YES cout << "YES\n"
#define NO cout << "NO\n"
#define ff first
#define ss second
#define fori(x,y) for(int i=x;i<=(int)(y);++i)
#define forj(x,y) for(int j=x;j<=(int)(y);++j)
#define fork(x,y) for(int k=x;k<=(int)(y);++k)

#define debug(x) cout << #x << " = " << x << endl

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

ll MOD = 998244353;
ll qpow(ll a,ll p) {ll res=1; while(p) {if (p&1) {res=res*a%MOD;} a=a*a%MOD; p>>=1;} return res;}

const int N = 5e3+7;
vector<int> g[N];

int scc[N], low[N], num[N];  // scc代表强连通分量的序号，low代表它所连接的最小祖先的序号，num代表访问到它时的序号
int dfn, cnt;  // dfn为访问序号，cnt记录强连通分量的个数和编号
stack<int> st;  // 用于保存属于同一个强连通分量的点
void dfs(int u) {
    st.push(u);
    low[u] = num[u] = ++dfn;  // 初始化
    fori(0, g[u].size()-1) {
        int v = g[u][i];
        if (!num[v]) {  // 如果没有访问过
            dfs(v);
            low[u] = min(low[u], low[v]);  // 递归返回子节点的low
        }
        else if (!scc[v]) {  // 如果子节点v访问过且不属于某一个强连通分量（好像直接else不加判断也可以）
            low[u] = min(low[u], num[v]);  // 该点的序号
        }
    }
    if (low[u] == num[u]) {  // 栈底：scc祖先
        cnt++;  // 这是一个新的强连通分量
        while (1) {
            int v = st.top();
            st.pop();
            scc[v] = cnt;  // 记录编号
            if (v == u) break;  // 栈底为该强连通分量的祖先节点
        }
    }
}

int siz[N], dp[N], deg[N];
vector<int> gg[N];

set<int> tmp;
void dfs2(int u) {
    tmp.insert(u);
    for (auto v: gg[u]) {
        if (tmp.find(v) != tmp.end()) continue;
        dfs2(v);
    }
}
void solve(int tt) {
	int n, m;
    cin >> n >> m;
    dfn = cnt = 0;
    fori(1, n) {
        g[i].clear();
        gg[i].clear();
        scc[i] = low[i] = num[i] = 0;
        siz[i] = dp[i] = deg[i] = 0;
    }
    fori(1, m) {
        int u, v;
        cin >> u >> v;
        u++, v++;
        g[u].push_back(v);
    }
    fori(1, n) if (!num[i]) dfs(i);
    fori(1, n) {
        siz[scc[i]]++;
        for (auto v: g[i]) {
            if (scc[v] == scc[i]) continue;
            gg[scc[v]].push_back(scc[i]);  // inverse
            deg[scc[i]]++;
        }
    }

    fori(1, cnt) {
        if (deg[i]) continue;
        tmp.clear();
        dfs2(i);
        int res = 0;
        for (auto u: tmp) res += siz[u];
        dp[i] = res;
    }
    

    set<int> sets;
    int ma = 0;
    fori(1, cnt) {
        if (dp[i]>ma) {
            ma = dp[i];
            sets.clear();
            sets.insert(i);
        }
        else if (dp[i] == ma) {
            sets.insert(i);
        }
    }

    vector<int> ans;
    fori(1, n) if (sets.find(scc[i]) != sets.end()) ans.push_back(i);
    sort(ans.begin(), ans.end());
    cout << "Case " << tt << ": " << ma-1 << endl;
    for (auto u: ans) cout << u-1 << " ";
    cout << endl;
}

signed main() {
	IOS;
	int t;
	cin >> t;
	fori(1, t) {
		solve(i);
	}
	return 0;
}
InfCraft
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ssm_traveller.zip
07-02
本压缩包“ssm_traveller.zip”提供的内容是一个基于SSM实现的旅游产品管理系统，涵盖了旅游产品模板、用户模块、订单模块、角色管理和日志管理等多个关键功能，旨在提供一个完整的业务流程解决方案。 首先，我们来...
traveller.demo
09-24
"traveller.demo" 是一个已完成的iOS应用项目，它具有详尽的注释，方便理解和学习。项目中集成了CocoaPods，这是一个广泛使用的依赖管理工具，它使得引入和管理第三方库变得简单而高效。项目的标签为 "iOS, APP, ...
hdu多校第一场2023
m0_46268389的博客
07-19 186
【代码】hdu多校第一场2023。
2024HDU Contest 5 Problem 5
xiayuyang
08-03 669
倍数的点，则这条边的答案至少为d。考虑到对于每条边我们只需要知道最大值，所以如果一条边已经在之前的。中被更新过答案，我们就可以将它合并起来。合并的过程可以通过并查集来实现。每条边只会被合并一次，然后枚举倍数的时间开销也是调和级数，所以总复杂度为。的倍数的点之后，将这些点之间的路径都遍历一遍并合并起来。所以总结下来做法就是枚举出编号为。从大到小枚举gcd的值。
2024 杭电多校 第四场
landexiangmz的博客
07-31 880
以1）为例，wa>=wc>=wd，wd是在[0,wc]里最大的那个，我们在枚举wc时可以立马确定wd取值，于是我们从小到大枚举wc，就可以知道在当前wc范围内wd的最大取值。注意到n和m的数据范围比较小，去枚举每个数字选或者不选的复杂度O(2^n)，枚举所有异或和的情况O(2^m)，O(2^(n+m))加点优化，似乎正好能卡过。你现在位于 (0,0)，每次你可以选择从 (x,y) 移动到 (x+1,y) 或者 (x,y+1)，当你位于某个宝箱正上方时，你将可以挖出它并拿走里面的所有金币。
[题解 hduoj-7522] 2024HDU 暑假多校7 - cats 的最小生成树
qq_72715438的博客
08-12 455
有一个有重边的无向图, 每次找到它的最小生成树, 并删除生成树的边, 直到不存在最小生成树, 问被每条边在第几次被删除.考虑用类似 Kruskal 算法, 但是是遍历一遍所有边, 同时处理出来所有的生成树.
2024杭电多校4——1007 序列更新
theskyinblue的博客
08-11 402
取个倒数才是我们需要的形式,指数是i+1，所以相当于从1开始，所以。让它用第一种方式去更新,因为小的数更容易被更新,对于。(第二种方式),因为大的数更容易更新别的数。大概是因为两种维护方法都与b的第。一种比较玄学的优化方式，长知识了。
终端文字网络游戏 旅行者traveller.zip
04-14
这个C#实现的小游戏是一个简单的猜数字游戏，让玩家猜一个1到100之间的随机生成的数字。以下是对这个小游戏的分析： Random 类的使用：游戏开始时，使用 Random 类生成一个1到100之间的随机数作为要猜的数字。...
基于vue+ssm的旅游网站后台管理系统vue-ssm-traveller-manage.zip
04-06
前端技术： ... CSS ：用于设计网页外观和样式的样式表语言。 JavaScript：用于在网页上实现交互性和动态效果的脚本语言。 React：一个流行的JavaScript库，用于构建用户界面。 Angular：一个用于构建Web应用的前端框架...
2024杭电多校第七场
最新发布
xinchu0309的博客
08-14 899
2024杭电多校第七场
How Many Answers Are Wrong
xxkkx的博客
08-06 817
第 11 行输入两个整数 NN 和 MM，表示有 NN 个整数，MM 条信息。第 2∼M+12∼M+1 行中，每行输入 33 个整数 Li,Ri,ViLi​,Ri​,Vi​，表示 [Li,Ri][Li​,Ri​] 区间和为 ViVi​。有一个长度为 NN 的整数序列，其中的数未知；但有 MM 条信息，每条信息描述该序列中。保证任何子序列的和不超过 3232 位整数的范围。某些信息存在冲突（即能推出矛盾）。问有多少条这样的的信息？一行一个整数，表示有误信息的条数。然而，其中有一些信息与。
HDU 2017多校联赛-Regular polygon
知足常乐的博客
07-28 926
Problem Description On a two-dimensional plane, give you n integer points. Your task is to figure out how many different regular polygon these points can make.Input The input file consists of several
2018 hdu 多校 7
limn204的专栏
08-24 184
你们怎么什么都会？ 我是真的菜，签到都失败了，还做了5个小时假题 1001 Age of Moyu 这道题是假的，原题之后放到别处 1005 GuGuFishtion 首先通过强行对a，b进行质因数分解，我们可以发现 G=gcd(a,b)ϕ(gcd(a,b))G=gcd(a,b)ϕ(gcd(a,b))G = {gcd(a,b) \over \phi(gcd(a,b))} ...
hdu 多校联赛 Colorful Tree
江北绝尘
07-31 424
Colorful Tree HDU - 6035                              There is a tree with n nodes, each of which has a type of color represented by an integer, where the color of node i is ci. Th
杭电多校第四场 Blow up the Enemy
give it a try
07-30 411
题目传送 思路: 暴力即可，但是要注意，第一次俩者是不需要等待，直接发起攻击，所以在计算击杀对方时间的时候还要减去第一次所需要的时间 AC代码 #include <bits/stdc++.h> inline long long read(){char c = getchar();long long x = 0,s = 1; while(c < '0' || c > '9') {if(c == '-') s = -1;c = getchar();} while(c >= '0'
2021hdu多校1 Maximal submatrix(单调栈+简单dp)
07-22 188
**题意：**给你一个数字矩阵，让你找一个子矩阵，使其满足每一列是非递减的，输出最大的子矩阵的面积。 题解： 我们根据每一列进行非递减的dp，得到dp是以当前点为结尾的最大非降子序列。 然后根据我蓝书中一道单调栈的题(传送门)，我们可以将每一行的dp当做矩形的高，矩形的宽为1，直接单调栈即可完成计算 code： #include <bits/stdc++.h> using namespace std; typedef long long ll; const double PI = acos
2021“MINIEYE杯”中国大学生算法设计超级联赛（2）
eternity19的博客
07-25 407
2021“MINIEYE杯”中国大学生算法设计超级联赛（2）1008 I love exam (类背包DP)1010 I love permutation (数学构造，剩余系) 1008 I love exam (类背包DP) 描述 有t天时间复习，n种课程，m个复习资料，每个资料i可以花费yi天让一种课程 增加xi分，60分及格，满分100分，刚开始每门课程都只能考0分，最多可以允许你有p个课程不及格，求在满足要求的情况下所有课程能获得的最大总分。 题目链接 分析 代码 #include <bi
2018 hdu多校联合训练一（1）
反之亦然
07-31 682
6298 Maximum Multiple 把整数因式分解，3的倍数一定可以，最小质因数5以上不可能（分数相加关系），只要考虑2、3、4。只是2的倍数而不是4的倍数，不会有三个因数相加为原数 #include&lt;bits/stdc++.h&gt; #define ll long long using namespace std; int main() { int n; ...
编写程序：输入一个整数（代表某个人的年龄）。如果该值大于等于18，则打印You can vote。如果年龄在0到17岁之间，则打印 Too young to vote。如果年龄小于0，则打印You are a time traveller.
07-12
您好！以下是一个简单的Python程序，根据输入的年龄打印相应的提示信息： ```python age = int(input("请输入您的年龄: ")) if age >= 18: print("You can vote.") elif 0 <= age <= 17: print("Too young to vote.") else: print("You are a time traveller.") ``` 请注意，这个程序假设用户输入的是一个整数。如果用户输入的不是整数，程序将会抛出异常。为了保证程序的健壮性，您可以添加一些异常处理的代码来处理非整数输入情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值