分治

最新推荐文章于 2023-02-10 18:04:26 发布

偷瞄一眼

最新推荐文章于 2023-02-10 18:04:26 发布

阅读量352

点赞数

文章标签：算法分治算法

本文链接：https://blog.csdn.net/qq_56616709/article/details/120808085

版权

本文通过多个Codeforces竞赛中的编程题目，展示了分治策略在解决数组排序、字符串匹配、树形结构优化等问题上的应用。核心思想是在问题规模足够小的情况下直接求解，否则递归分解并合并子问题的解。文章列举的题目涵盖了基础到进阶的分治算法实例，适合初学者巩固和提升分治法的理解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

分治策略是：对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。

由于分治的东西我也讲不太清，觉得只有分到最后的判断需要明确就行，所以接下来就只是列写过题目。

题目

Codeforces Round #702 (Div. 3) D. Permutation Transformation

Codeforces Round #656 (Div. 3) D. a-Good String

Codeforces Round #722 (Div. 1) A. Parsa's Humongous Tree

Codeforces Round #689 (Div. 2, based on Zed Code Competition) D. Divide and Summarize

Codeforces Round #313 (Div. 1) B. Equivalent Strings

总结

题目

Codeforces Round #702 (Div. 3) D. Permutation Transformation

这道题算是基本题了，看tag是有dfs的标签，直接搜索在进行分段就行。

#include<iostream>
#include<cmath>
#include<string>
#include<iomanip>
#include<malloc.h>

using namespace std;
typedef long long ll;

struct node {
	int* left, * right;
	int depth;
};

int a[105],b[105];

int mmax(int* a, int le, int ri)
{
	int k, maxx = -1e10;
	for (int i = le;i <= ri;i++)
	{
		if (a[i] > maxx)
		{
			maxx = a[i];
			k = i;
		}
	}
	return k;
}

void merge(int* a, int le, int ri, int dep)
{
	if (le == ri)
	{
		b[le] = dep;
		return;
	}
	int maxx = mmax(a, le, ri);
	b[maxx] = dep;
	dep++;
	if (le <= maxx - 1)
		merge(a, le, maxx - 1, dep);
	if (maxx + 1 <= ri)
		merge(a, maxx + 1, ri, dep);
}
int main()
{
	int n,t;
	cin >> t;
	memset(a, 0, sizeof(a));
	memset(b, 0, sizeof(b));
	while (t--)
	{
		cin >> n;
		for (int i = 0;i < n;i++)
		{
			cin >> a[i];
		}
		merge(a, 0, n - 1, 0);
		for (int i = 0;i < n;i++)
			cout << b[i] << " ";
		cout << endl;
	}


}

Codeforces Round #656 (Div. 3) D. a-Good String

#include<iostream>
#include<cmath>
#include<string>
#include<iomanip>
#include<malloc.h>

using namespace std;
typedef long long ll;

char s[131077];

int merge(int le,int ri,char x)
{
	if (le == ri-1)
	{
		if (s[le] == x)
			return 0;
		else return 1;
	}
	int mid = (le + ri) / 2;
	int lnum = 0, rnum = 0;
	for (int i = le;i < mid;i++)
	{
		if (s[i] != x)
			lnum++;
	}
	for (int i = mid;i < ri;i++)
	{
		if (s[i] != x)
			rnum++;
	}
	int k = min(merge(le, mid, x + 1) + rnum, merge(mid, ri, x + 1) + lnum);
	return k;
}
int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int n;
		scanf("%d", &n);
		scanf("%s", s);
		printf("%d\n", merge(0, n, 'a'));

	}



}

Codeforces Round #722 (Div. 1) A. Parsa's Humongous Tree

#include<iostream>
#include<cmath>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;
typedef long long ll;



ll a[100005][2];
ll dp[100005][2];
vector<int >g[100005];

void ddpp(int now,int la)
{
	for (int i = 0;i < g[now].size();i++)
	{
		if (g[now][i] == la)
			continue;
		ddpp(g[now][i], now);
		dp[now][0] += max(dp[g[now][i]][0] + abs(a[now][0] - a[g[now][i]][0]), dp[g[now][i]][1] + abs(a[now][0] - a[g[now][i]][1]));
		dp[now][1] += max(dp[g[now][i]][0] + abs(a[now][1] - a[g[now][i]][0]), dp[g[now][i]][1] + abs(a[now][1] - a[g[now][i]][1]));
	}
}


int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int n;
		scanf("%d", &n);
		memset(dp, 0, sizeof(dp));
		for (int i = 1;i <= n;i++)
		{
			g[i].clear();
			scanf("%lld%lld", &a[i][0], &a[i][1]);
		}
		for (int i = 0;i < n - 1;i++)
		{
			int x, y;
			scanf("%d%d", &x, &y);
			g[x].push_back(y);
			g[y].push_back(x);
		}
		ddpp(1, -1);
		printf("%lld\n", max(dp[1][0], dp[1][1]));

	}
	
	return 0;
}

Codeforces Round #689 (Div. 2, based on Zed Code Competition) D. Divide and Summarize

#include<iostream>
#include<cmath>
#include<string>
#include<vector>
#include<algorithm>
#include<map>

using namespace std;
typedef long long ll;

map<ll, int > g;
ll a[100005];

ll dfs(int le,int ri)
{
	if (le == ri||le>ri)
	{
		g[a[le]] = 1;
		return a[le];
	}
	ll mid = (a[le] + a[ri]) / 2;
	int now=le;
	for (int i = le;i <= ri;i++)
	{
		if (a[i] > mid)
		{
			now = i;
			break;
		}
	}
	if (now == le)
	{
		ll k = a[le] * (ri - le + 1);
		g[k] = 1;
		return k;
	}
	ll sum = dfs(now, ri) + dfs(le, now - 1);
	g[sum] = 1;
	return sum;
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int n, q;
		g.clear();
		memset(a, 0, sizeof(a));
		scanf("%d%d", &n, &q);
		for (int i = 0;i < n;i++)
		{
			scanf("%lld", &a[i]);
		}
		sort(a, a + n);
		dfs(0, n - 1);
		for (int i = 0;i < q;i++)
		{
			ll k;
			scanf("%lld", &k);
			if (g[k])
				printf("Yes\n");
			else printf("No\n");
		}
	}
	
	return 0;
}

Codeforces Round #313 (Div. 1) B. Equivalent Strings

#include<iostream>
#include<cmath>
#include<string>
#include<vector>
#include<algorithm>
#include<map>

using namespace std;
typedef long long ll;

string a, b;

int merge(int al,int ar,int bl,int br)
{
	int len = ar - al + 1;
	if (a.substr(al, len) == b.substr(bl, len))
		return 1;
	if (len % 2 == 1)
		return 0;
	int amid = (al + ar) / 2;
	int bmid = (bl + br) / 2;
	if (merge(al, amid, bmid + 1, br) && merge(amid + 1, ar, bl, bmid))
		return 1;
	if (merge(al, amid, bl, bmid) && merge(amid + 1, ar, bmid + 1, br))
		return 1;
	return 0;
}


int main()
{
	cin >> a >> b;
	if (merge(0, a.length() - 1, 0, b.length() - 1))
		printf("YES");
	else printf("NO");
	
	return 0;
}