【套题】qbxt国庆刷题班D2

D2

今天的题感觉还是好妙的

T1

传送门

Description

现在有一张\(n\)个节点\(m\)条边的无向连通图\(G=(V,E)\)，满足这张图中不存在长度大于等于3的环且图中没有重边和自环。

定义两个点\(u,v\)的距离\(d(u,v)\)为这两个点之间最短路上的点数，求

\[min_{u~\in~V}~max_{v~\in~V}~d(u,v)
\]

Input

第一行两个正整数n,m，表示点数边数

接下来\(m\)行，每行两个正整数，描述一条无向边

Output

一行一个整数代表答案。

Sample Input

7 6
1 2
1 6
2 5
3 1
4 7
2 4

Sample Output

3

Hint

\(For~All:\)

\(n,m~\leq~10^5\)

\(For~30~percent:\)

\(n,m~\leq~20\)

\(For~60~percent:\)

\(n,m~\leq~1000\)

Solution

考虑这个十分煞笔的描述……其实这是棵树

题意是让你找到一个点，使得这个点到最远的点的距离最小

考虑30分做法，直接Floyd即可

考虑60分做法……我不知道60分怎么做

考虑100做法。一个点像最远的点的路径只有可能有两种情况，分别是向上走和向下走的两种情况于是可以先一遍dfs确定一个点向下的最长路，然后树形DP求出这个点的最长路。具体的，对每个节点维护最长路和次长路，无需严格次长，同时维护分别是从哪里转移。显然根节点的最长路是向下的。对于一个非根节点，如果它的父亲的最长路是转移向他的，那么将它的最长路即为父亲的次长路，否则记为最长路。然后枚举这个节点的子节点，求出他向下的最长路，进行转移。至此这个节点的最长路与次长路已经被全部求出，然后可以枚举他的子节点向子节点转移。

hjc说这是个结论题。可我觉得这就是个树形DP吖？

Code

#include<cstdio>
#define rg register
#define ci const int
#define cl const long long int

namespace IO {
    char buf[110];
}

template <typename T>
inline void qr(T &x) {
    char ch=getchar(),lst=' ';
    while((ch > '9') || (ch < '0')) lst=ch,ch=getchar();
    while((ch >= '0') && (ch <= '9')) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    if(lst == '-') x=-x;
}

template <typename T>
inline void write(T x,const char aft,const bool pt) {
    if(x < 0) {putchar('-');x=-x;}
    rg int top=0;
    do {
        IO::buf[++top]=x%10+'0';x/=10;
    } while(x);
    while(top) putchar(IO::buf[top--]);
    if(pt) putchar(aft);
}

template <typename T>
inline T mmax(const T a,const T b) {return a > b ? a : b;}
template <typename T>
inline T mmin(const T a,const T b) {return a < b ? a : b;}
template <typename T>
inline T mabs(const T x) {return x < 0 ? -x : x;}

template <typename T>
inline void mswap(T &a,T &b) {
    T temp=a;a=b;b=temp;
}

const int maxn = 100010;
const int maxm = 200010;

struct Edge {
    int to,nxt;
};
Edge edge[maxm];int hd[maxn],ecnt;
inline void cont(ci from,ci to) {
    Edge &e=edge[++ecnt];
    e.to=to;e.nxt=hd[from];hd[from]=ecnt;
}

int n,m,ans=0x3f3f3f3f;
int fa[maxn],frog[maxn][3],md[maxn],pre[maxn];

void DFS(ci);
void reading();
void dfs(ci,ci);

int main() {
    freopen("distance.in","r",stdin);
    freopen("distance.out","w",stdout);
    qr(n);qr(m);
    reading();
    dfs(1,0);
    DFS(1);
    write(ans,'\n',true);
    return 0;
}

void reading() {
    rg int a,b;
    while(m--) {
        a=b=0;qr(a);qr(b);
        cont(a,b);cont(b,a);
    }
}

void dfs(ci u,ci fat) {
    fa[u]=fat;
    for(rg int i=hd[u];i;i=edge[i].nxt) {
        int &to=edge[i].to;
        if(to == fat) continue;
        dfs(to,u);
        md[u]=mmax(md[u],md[to]);
    }
    ++md[u];
}

void DFS(ci u) {
    if(pre[fa[u]] != u) frog[u][1]=frog[fa[u]][1]+1;
    else frog[u][1]=frog[fa[u]][2]+1;
    pre[u]=fa[u];
    for(rg int i=hd[u];i;i=edge[i].nxt) {
        int &to=edge[i].to;
        if(to == fa[u]) continue;
        if(frog[u][1] < (md[to]+1)) frog[u][2]=frog[u][1],frog[u][1]=md[to]+1,pre[u]=to;
        else if(frog[u][2] < (md[to]+1)) frog[u][2]=md[to]+1;
    }
    for(rg int i=hd[u];i;i=edge[i].nxt) {
        int &to=edge[i].to;
        if(to == fa[u]) continue;
        DFS(to);
    }
    ans=mmin(ans,frog[u][1]);
}

T2

传送门

Description

给你一张\(n\)个点\(m\)条边的无向图，每条边有一个权值\(w_i\)。

求一条\(S\)到\(T\)的路径，使得这条路上权值最大的边比权值最小的边比值最小

Input

第一行是两个正整数\(n,m\)，代表图的点数和边数

接下来的\(m\)行每行三个正整数\(x,y,w\)，代表一条权值为\(w\)的边

最后一行两个正整数\(S,T\)

Output

如果\(S\)到\(T\)不连通输出\(IMPOSSIBLE\)，否则输出答案

答案形如一个A/B的既约分数

Hint

\(For~All:\)

\(1~\leq~n~\leq~500,1~\leq~m~\leq~5000,1~\leq~w~\leq~30000,x~\neq~y,S~\neq~T\)

\(For~20~percents:\)

\(n,m~\leq~5\)

\(For~other~30~percents:\)

\(n~\leq~100,m~\leq~200,w~\leq~100\)

Solution

考虑前20分可以暴力枚举选哪些边

剩下30分做法，考虑所有的元素都只有几百，于是可以使用bool型DP来做这道题。

可以设\(f_{i,j,k}=true/false\)代表从\(S\)到点\(i\)，是否存在一个最大值为\(j\)，最小值是\(k\)的路径。转移我不会。

我的做法是two points乱搞。考虑枚举最小的边，然后发现最小的边权单调不降时，最大的边权也单调不降。于是可以\(Two~points\)省掉最大边权的枚举。每次指针移动时暴力bfs判断连通性。于是复杂度\(O(m^2)\)，其实就A了。然而我数组开小了，于是挂了50

考虑std的满分做法。发现边依然可以枚举。于是考虑枚举最小的边，发现问题等价于求一个最小瓶颈路。然后枚举最小边求暴力克鲁斯卡尔就可以AC。

Code

这代码写的可真丑

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;

const int N = (int)1e4;
typedef int arr[N + 10];

int n, m, S, T;
arr ufs;
int bestnum, bestdenom;

struct edge {
	int x, y, w;
}e[N + 10];

int find(int x) { return ufs[x] == x ? x : ufs[x] = find(ufs[x]); }

int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }

bool cmp(const edge &a, const edge &b) { return a.w < b.w; }

int main() {
	freopen("graph.in", "r", stdin);
	freopen("graph.out", "w", stdout);

	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; ++i) scanf("%d %d %d", &e[i].x, &e[i].y, &e[i].w);
	scanf("%d %d", &S, &T);

	sort(e + 1, e + m + 1, cmp);

	bestnum = 30001, bestdenom = 1;
	for (int i = 1; i <= m; ++i) {
		for (int j = 1; j <= n; ++j) ufs[j] = j;
		int j = i;
		for ( ; j <= m; ++j) {
			int fx = find(e[j].x), fy = find(e[j].y);
			if (fx != fy) ufs[fx] = fy;
			if (find(S) == find(T)) break;
		}

		if (find(S) == find(T)) {
			if (e[j].w * bestdenom < e[i].w * bestnum)
				bestnum = e[j].w, bestdenom = e[i].w;
		}
	}

	if (bestnum == 30001) printf("IMPOSSIBLE\n");
	else {
		int g = gcd(bestnum, bestdenom);
		bestnum /= g, bestdenom /= g;
		if (bestdenom == 1) printf("%d\n", bestnum);
		else printf("%d/%d\n", bestnum, bestdenom);
	}

	return 0;
}

T3

传送门

Description

有一个小学生去买糖，商店中共有n种不同的糖果，其中每一种糖果有两种选择：大糖果和小糖果各自只有一个，并且各自有一个价格。满足大糖果一定比小糖果贵。对于任意一种糖果，大糖果给小学生带来的愉悦度是2，小糖果给小学生带来的愉悦度是1。由于小学生不喜欢口味相同的糖果，所以对于一种糖果，他不会同时买大糖果和小糖果。

现在小朋友想要获得P点愉悦度，但花费最少的钱。请你帮帮他。

Input

第一行两个整数\(n,p\)

接下来\(n\)行，每行两个整数\(a_i\)和\(b_i\)，表示第\(i\)种糖果小糖果和大糖果的价格。

Output

共输出\(n+1\)行。

第一行输出最小花费

对于\(i~\in~[2,n+1]\)，第\(i\)行输出第\(i-1\)种糖果买大买小还是不买。不买输出\(0\),买小输出\(1\),买大输出\(2\)。如果有多种方案，那你就凉了。因为我不会写spj

Hint

\(For~All:\)

\(n~\leq~2~\times~10^5,a_i~\le~b_i,p~\leq~2~\times~n,b_i~\leq~2^21-1\)

\(For~30~percents:\)

\(n~\leq~10\)

\(For~other~20~percents:\)

\(n~\leq~1000,1~\leq~a_i~\leq~10~,~100~\leq~b_i~\leq~1000\)

Solution

显然可以DP。这样可以拿50分。

考虑贪心。

另外20分的做法。题目给定了\(a_i~\times~2~<~b_i\)

于是把两个糖果改为两个贡献都是\(1\)的，价格分别是\(a_i\)和\(b_i-a_i\)，于是按照价格排序直接排序贪心。因为\(a_i\)显然小于\(b_i-a_i\)，于是选了后者的时候一定选择了前者。贪心正确

考虑正解

于是就完了