算法设计与分析

最新推荐文章于 2024-09-12 19:02:20 发布
最新推荐文章于 2024-09-12 19:02:20 发布
阅读量617 收藏 10
点赞数 12
文章标签： 算法 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxwl123/article/details/135396623
版权

第2章 分治

1、棋盘覆盖

// 棋盘覆盖
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;

int tile = 0, board[105][105];
void chessBoard(int tr, int tc, int dr, int dc, int size)
{
	if (size == 1){
		return ;
	}
	int t = ++tile;
	int s = size / 2;
	if (dr < tr + s and dc < tc + s){
		chessBoard(tr, tc, dr, dc, s);
	}else{
		board[tr + s - 1][tc + s -1] = t;
		chessBoard(tr, tc, tr + s - 1, tc + s - 1, s);
	}
	if (dr < tr + s and dc >= tc + s){
		chessBoard(tr, tc + s, dr, dc, s);
	}else{
		board[tr + s - 1][tc + s] = t;
		chessBoard(tr, tc + s, tr + s - 1, tc + s, s);
	}
	if (dr >= tr + s and dc < tc + s){
		chessBoard(tr + s, tc, dr, dc, s);
	}else{
		board[tr + s][tc + s - 1] = t;
		chessBoard(tr + s, tc, tr + s, tc + s - 1, s);
	}
	if (dr >= tr + s and dc >= tc + s){
		chessBoard(tr + s, tc + s, dr, dc, s);
	}else{
		board[tr + s][tc + s] = t;
		chessBoard(tr + s, tc + s, tr + s, tc + s, s);
	}
}

int main()
{
	int dr, dc, n;
	cin>>dr>>dc>>n;
	int size = pow(2, n);
	chessBoard(1, 1, dr, dc, size);
	for (int i = 1; i <= size; i++){
		for(int j = 1; j <= size; j++){
			cout<<board[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
}

2、归并排序

#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;
int a[10005], b[10005], n;

void merge(int left, int mid, int right)
{
	int i = left, j = mid + 1, k = left;
	while(i <= mid and j <= right){
		if(a[i] <= a[j]){
			b[k] = a[i];
			i++;
		}else{
			b[k] = a[j];
			j++;
		}
		k++;
	}
	while(i <= mid){
		b[k++] = a[i++];
	}
	while(j <= right){
		b[k++] = a[j++];
	}
	for(int i = left; i <= right; i++){
		a[i] = b[i];
	}
}

void merge_sort(int left, int right)
{
	if(left < right){
		int mid = (left + right) / 2;
		merge_sort(left, mid);
		merge_sort(mid + 1, right);
		merge(left, mid, right);
	}
}

int main()
{
	cin>>n;
	for(int i = 1; i <= n; i++){
		cin>>a[i];
	} 
	merge_sort(1, n);
	for(int i = 1; i <= n; i++){
		cout<<a[i]<<" ";
	} 
	cout<<endl;
	return 0;
}

3、快速排序

#include<iostream>
using namespace std;

int a[1005], n;
int partition(int low, int high)
{
	int i = low, j = high;
	int x = a[low];
	while(i != j){
		while(a[j] >= x and i < j) j--;
		while(a[i] <= x and i < j) i++;
		swap(a[i], a[j]);
	}
	swap(a[i], a[low]);
	return i;
}

void quick_sort(int p, int r)
{
	if(p < r){
		int q = partition(p, r);
		quick_sort(p, q - 1);
		quick_sort(q + 1, r);
	}
}

int main()
{
	cin>>n;
	for(int i = 1; i <= n; i++){
		cin>>a[i];
	} 
	quick_sort(1, n);
	for(int i = 1; i <= n; i++){
		cout<<a[i]<<" ";
	} 
	cout<<endl;
	return 0;
}

4、循环赛日程表

#include<iostream>
using namespace std;

int a[105][105];
void solve(int r, int c, int l, int v)
{
	if (l == 1) {
		a[r][c] = v;
		return ;
	}
	int mid = l / 2;
	solve(r, c, mid, v);
	solve(r + mid, c, mid, v + mid);
	solve(r, c + mid, mid, v + mid);
	solve(r + mid, c + mid, mid, v);
}

int main()
{
	int n;
	cin>>n;
	solve(1, 1, n, 1);
	for (int i = 1; i <= n; i++){
		for(int j = 1; j <= n; j++){
			cout<<a[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
}

5、整数因子分解(重复)

#include<bits/stdc++.h>
using namespace std;
 
int total;
void solve(int n) {
    if (n == 1){
		total++;
	}else {
        for (int i = 2; i <= n; i++)
            if (n % i == 0) solve(n / i); 
    }
}
 
int main() 
{
    int n;
    total = 0; 
    cin>>n;
    solve(n);
	cout<<total<<endl; 
    return 0;
}

6、整数因子分解（去重）

#include<bits/stdc++.h>
using namespace std;
 
int total;
void solve(int n, int start) {
    if (n == 1){
		total++;
	}else {
        for (int i = start; i <= n; i++)
            if (n % i == 0) solve(n / i, i); 
    }
}
 
int main() 
{
    int n;
    total = 0; 
    cin>>n;
    solve(n, 2);
	cout<<total<<endl; 
    return 0;
}

7、全排列

#include<iostream>
using namespace std;

int n, x[105];

void perm(int t)
{
	if(t > n){
		for(int i = 1; i <= n; i++){
			cout<<x[i]<<" ";
		}
		cout<<endl;
		return ;
	}
	for(int i = t; i <= n; i++){
		swap(x[t], x[i]);
		perm(t + 1);
		swap(x[t], x[i]);
	}
}

int main()
{
	cin>>n;
	for(int i = 1; i <= n; i++){
		x[i] = i;
	}
	perm(1);
	return 0;
}

8、汉诺塔

// a移到b
#include<iostream>
using namespace std;

void hanoi(int n, char a, char b, char c)
{
	if(n > 0){
		hanoi(n-1, a, c, b);
		cout<<a<<"--->"<<b<<endl;
		hanoi(n-1, c, b, a);
	}
}

int main()
{
	int n;
	cin>>n;
	hanoi(n, 'a', 'b', 'c');
	return 0;
}

// a移到c
#include<iostream>
using namespace std;

void hanoi(int n, char a, char b, char c)
{
	if(n > 0){
		hanoi(n-1, a, c, b);
		cout<<a<<"--->"<<c<<endl;
		hanoi(n-1, b, a, c);
	}
}

int main()
{
	int n;
	cin>>n;
	hanoi(n, 'a', 'b', 'c');
	return 0;
}

第3章 动态规划

1、矩阵连乘

#include<iostream>
using namespace std;

int p[1005], dp[1005][1005], n, s[1005][1005];

void Traceback(int i, int j)   // 打印最优解
{
	if (i == j) return ;
	Traceback(i, s[i][j]);
	Traceback(s[i][j] + 1, j);
	cout<<"Multiply A "<<i<<", "<<s[i][j];
	cout<<" and A "<<(s[i][j] + 1)<<", "<<j<<endl;
	return ;
}

int main()
{
	cin>>n;
	for(int i = 0; i <= n; i++){
		cin>>p[i];
	}
	for(int i = 1; i <= n; i++){
		dp[i][i] = 0;
	}
	for(int r = 2; r <= n; r++){
		for(int i = 1; i <= n - r + 1; i++){
			int j = i + r - 1;
			dp[i][j] = dp[i+1][j] + p[i-1] * p[i] * p[j];
			s[i][j] = i;
			for (int k = i + 1; k < j; k++){
				int t = dp[i][k] + dp[k+1][j] + p[i-1] * p[k] * p[j];
				if (t < dp[i][j]){
					dp[i][j] = t;
					s[i][j] = k;
				}
			}
		}
	}
	cout<<dp[1][n]<<endl;
	Traceback(1, n);
	return 0;
}

/*
6
30 35 15 5 10 20 25
*/

2、01背包

#include<iostream>
using namespace std;

struct node{
	int weight, value;
}nodes[1005];

int dp[105][105];
int main()
{
	int n, w;
	cin>>n>>w;
	for(int i = 1; i <= n; i++){
		cin>>nodes[i].weight>>nodes[i].value;
	}
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= w; j++){
			if (j < nodes[i].weight){
				dp[i][j] = dp[i-1][j];
			}else{
				dp[i][j] = max(dp[i-1][j], dp[i-1][j - nodes[i].weight] + nodes[i].value);
			}
		}
	}
	cout<<dp[n][w]<<endl;
	return 0;
}

3、最长公共子序列

#include<iostream>
using namespace std;

string s1, s2;
int dp[1005][1005];

int main()
{
	cin>>s1>>s2;
	int l1 = s1.size(), l2 = s2.size();
	for(int i = 1; i <= l1; i++){
		for(int j = 1; j <= l2; j++){
			if (s1[i - 1] == s2[j - 1]){
				dp[i][j] = dp[i-1][j-1] + 1;
			}else{
				dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
			}
		}
	}
	cout<<dp[l1][l2]<<endl;
	return 0;
}

4、最大字段和

#include<iostream>
using namespace std;

int dp[1005], x[1005], maxsum = 0;

int main()
{
	int n;
	cin>>n;
	for(int i = 1; i <= n; i++){
		cin>>x[i];
	}
	for(int i = 1; i <= n; i++){
		dp[i] = max(dp[i-1] + x[i], x[i]);
		if(dp[i] > maxsum){
			maxsum = dp[i];
		}
	}
	cout<<maxsum<<endl;
	return 0;
}

5、最长上升子序列

#include<bits/stdc++.h>
using namespace std;
int dp[10005], a[10005];
int main()
{
	int n;
	cin>>n;
	for (int i = 1; i <= n; i++) cin>>a[i];
	for (int i = 1; i <= n; i++){
		dp[i] = 1;
		for (int j = 1; j < i; j++){
			if (a[j] < a[i]) dp[i] = max(dp[i], dp[j] + 1);
		}
	}
	int res = 0;
	for (int i = 1; i <= n; i++){
		res = max(res, dp[i]);
	}
	cout<<res<<endl;
	return 0;
}
/*
7
1 7 3 5 9 4 8
*/

6、01背包（扩展）

#include<bits/stdc++.h>
using namespace std;

int dp[105][105][105], w[105], b[105], v[105];

int main()
{
	int n, weight, volume;
	cin>>n>>weight>>volume;
	for (int i = 1; i <= n; i++){
		cin>>w[i]>>b[i]>>v[i];
	}
	for (int i = 1; i <= n; i++){
		for (int j = 1; j <= weight; j++){
			for (int k = 1; k <= volume; k++){
				if (j >= w[i] and k >= b[i]){
					dp[i][j][k] = max(dp[i-1][j][k], dp[i-1][j-w[i]][k-b[i]] + v[i]);
				}else{
					dp[i][j][k] = dp[i-1][j][k];
				}
			}
		}
	}
	cout<<dp[n][weight][volume]<<endl;
	return 0;
}

/*
20 15 3
11 7 9
9 5 10
7 10 5
*/

第4章 贪心算法

1、最优装载

#include<iostream>
#include<algorithm>
using namespace std;

int a[1005];
int main()
{
	int n, c;
	cin>>n>>c;
	for(int i = 1; i <= n; i++){
		cin>>a[i];
	}
	sort(a + 1, a + n + 1);
	int cnt = 0;
	for(int i = 1; i <= n; i++){
		if (a[i] <= c){
			cnt++;
			c -= a[i];
		}
	}
	cout<<cnt<<endl;
	return 0;
}

2、活动安排

#include<iostream>
#include<algorithm>
using namespace std;

struct node{
	int start, end;
}nodes[1005];

bool cmp(struct node s1, struct node s2)
{
	return s1.end < s2.end;
}

int main()
{
	int n;
	cin>>n;
	for(int i = 1; i <= n; i++){
		cin>>nodes[i].start>>nodes[i].end;
	}
	sort(nodes + 1, nodes + 1 + n, cmp);
	int cnt = 1, r = nodes[1].end;
	for(int i = 2; i <= n; i++){
		if (nodes[i].start >= r){
			cnt++;
			r = nodes[i].end;
		}
	}
	cout<<cnt<<endl;
	return 0;
}

3、Dijkstra算法

#include<iostream>
using namespace std;
const int inf = 0x3f3f3f;

int a[1005][1005], dis[1005], vis[1005];
int nodes, edges;

void dijkstra(int x)
{
	fill(dis + 1, dis + nodes + 1, inf);
	vis[x] = 1;
	dis[x] = 0;
	for(int i = 1; i <= nodes; i++){
		dis[i] = a[1][i];
	}
	for(int i = 1; i < nodes; i++){
		int j = 1, mindis = inf;
		for(int k = 1; k <= nodes; k++){
			if(!vis[k] and dis[k] < mindis){
				mindis = dis[k];
				j = k;
			}
		}
		vis[j] = 1;
		for(int k = 1; k <= nodes; k++){
			if(!vis[k] and dis[j] + a[j][k] < dis[k]){
				dis[k] = dis[j] + a[j][k];
			}
		}
	}
	return ;
}

int main()
{
	cin>>nodes>>edges;
	for(int i = 1; i <= edges; i++){
		int from, end, d;
		cin>>from>>end>>d;
		a[from][end] = d;
		a[end][from] = d;
	}
	dijkstra(1);
	for(int i = 1; i <= nodes; i++){
		cout<<dis[i]<<" ";
	}
	cout<<endl;
	return 0;
}

/*
4 6
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4
*/

4、Prim算法

#include<iostream>
using namespace std;
const int inf = 0x3f3f3f;

int a[1005][1005], dis[1005], vis[1005];
int nodes, edges, ans;

void prim(int x)
{
	fill(dis + 1, dis + nodes + 1, inf);
	vis[x] = 1;
	dis[x] = 0;
	for(int i = 1; i <= nodes; i++){
		dis[i] = a[1][i];
	}
	for(int i = 1; i < nodes; i++){
		int j = 1, mindis = inf;
		for(int k = 1; k <= nodes; k++){
			if(!vis[k] and dis[k] < mindis){
				mindis = dis[k];
				j = k;
			}
		}
		ans += mindis;
		vis[j] = 1;
		for(int k = 1; k <= nodes; k++){
			if(!vis[k] and a[j][k] < dis[k]){
				dis[k] = a[j][k];
			}
		}
	}
	return ;
}

int main()
{
	cin>>nodes>>edges;
	for(int i = 1; i <= edges; i++){
		int from, end, d;
		cin>>from>>end>>d;
		a[from][end] = d;
		a[end][from] = d;
	}
	prim(1);
	cout<<ans<<endl;
	return 0;
}

/*
4 6
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4
*/

5、Kruskal算法

#include<iostream>
#include<algorithm>
using namespace std;

struct edge{
	int from, to, w;
}edges[1005];

int pre[1005], ans;
int find(int x)   // 查找根元素，并查集
{
	if(pre[x] != x){
		pre[x] = find(pre[x]);
	}
	return pre[x];
}

bool cmp(struct edge s1, struct edge s2)
{
	return s1.w < s2.w;
}

int main()
{
	int n, edge_num;
	cin>>n>>edge_num;
	for(int i = 1; i <= edge_num; i++){
		cin>>edges[i].from>>edges[i].to>>edges[i].w;
	}
	for(int i = 1; i <= n; i++){
		pre[i] = i;
	}
	sort(edges + 1, edges + edge_num + 1, cmp);
	for(int i = 1; i <= edge_num; i++){
		int a = find(edges[i].from);
		int b = find(edges[i].to);
		if(a != b){
			ans += edges[i].w;
			pre[b] = a;
		}
	}
	cout<<ans<<endl;
	return 0; 
}

第5章 回溯法

1、全排列

#include<iostream>
using namespace std;

int n, x[1005], vis[1005];

void backtrack(int t)
{
	if (t > n){
		for (int i = 1; i <= n; i++){
			cout<<x[i]<<" "; 
		}
		cout<<endl;
		return ;
	}
	for(int i = 1; i <= n; i++){
		if(!vis[i]){
			x[t] = i;
			vis[i] = 1;
			backtrack(t + 1);
			vis[i] = 0;
		}
	}
}

int main()
{
	cin>>n;
	backtrack(1);
	return 0;
}

/*
3
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
*/

2、01背包

#include<bits/stdc++.h>
using namespace std;

struct node{
	int w;
	int v;
}nodes[1005];

int wr, vw, bestvw, w, n, c;

void backtrack(int i)
{
	if (i > n){
		if(vw > bestvw){
			bestvw = vw;
		}
		return ;
	}
	if (wr + nodes[i].w <= c){
		wr += nodes[i].w;
		vw += nodes[i].v;
		backtrack(i + 1);
		wr -= nodes[i].w;
		vw -= nodes[i].v;
	}
	backtrack(i + 1);
}

int main()
{
	cin>>n>>c;
	for(int i = 1; i <= n; i++){
		cin>>nodes[i].w>>nodes[i].v;
	}
	backtrack(1);
	cout<<bestvw<<endl;
	return 0;
} 

/*
4 7
1 1
3 4
4 5
5 7
9
*/

3、n皇后

#include<iostream>
#include<cmath> 
using namespace std;

int x[1005], n, sum;

bool judge(int t)
{
	for(int i = 1; i < t; i++){
		if(x[i] == x[t] || t - i == abs(x[t] - x[i])){
			return false;
		}
	}
	return true;
}

void backtrack(int t)
{
	if(t > n){
		sum++;
		return ;
	}
	for(int i = 1; i <= n; i++){
		x[t] = i;
		if(judge(t)){
			backtrack(t + 1);
		}
	}
}
int main()
{
	cin>>n;
	backtrack(1);
	cout<<sum<<endl;
	return 0;
}

4、符号三角形

#include<iostream>
using namespace std;

int x[1005][1005], n, res, sum;

void backtrack(int t)
{
	if(t > n){
		int cnt = 0;
		for(int i = 2; i <= n; i++){
			for(int j = 1; j <= n - i + 1; j++){
				x[i][j] = x[i-1][j] * x[i-1][j+1];
			}
		}
		for(int i = 1; i <= n; i++){
			for(int j = 1; j <= n-i+1; j++){
				if(x[i][j] == 1){
					cnt++;
				}
			}
		}
		if (cnt == sum / 2){
			res++;
			for(int i = 1; i <= n; i++){
				for(int j = 1; j <= n - i + 1; j++){
					x[i][j] == 1 ? cout<<"+"<<" " : cout<<"-"<<" ";
				}
				cout<<endl;
			}
			cout<<endl;
		}
		return ;
	}else{
		for(int i = -1; i <= 1; i+=2){
			x[1][t] = i;
			backtrack(t+1);
		}
	}
}

int main()
{
	cin>>n;
	sum = (n * (n + 1)) / 2;
	if(sum % 2 == 0){
		backtrack(1);
		cout<<res<<endl;
	}else{
		cout<<0<<endl;
	}
	return 0;
}

5、装载问题

#include<iostream>
using namespace std;

int w[1005], cw, n, c, bestcw;

void backtrack(int t)
{
	if(t > n){
		if(cw > bestcw){
			bestcw = cw;
		}
		return ;
	}
	if(cw + w[t] <= c){
		cw += w[t];
		backtrack(t + 1);
		cw -= w[t];
	}
	backtrack(t+1);
}

int main()
{
	cin>>n>>c;
	for(int i = 1; i <= n; i++){
		cin>>w[i];
	}
	backtrack(1);
	cout<<bestcw<<endl;
	return 0;
}

/*
6 100
20 15 20 35 45 1
*/

其他

1、二分搜索

#include<iostream>
using namespace std;

int a[1005], n;

int binary_search(int x)
{
	int low = 1, high = n;
	while(low <= high){
		int mid = (low + high) / 2;
		if(a[mid] == x){
			return mid;
		}else if(a[mid] < x){
			low = mid + 1;
		}else{
			high = mid - 1;
		}
	}
	return -1;
}
int main()
{
	cin>>n;
	for(int i = 1; i <= n; i++){
		cin>>a[i];
	}
	cout<<binary_search(10)<<endl;  // 查找数字10 
	return 0;
} 

/*
10
1 3 6 10 11 15 17 19 20 25
*/

2、阶乘和Fibonacci数列

// 阶乘
#include<iostream>
using namespace std;

int f(int n)
{
	if (n == 1) return 1;
	return n * f(n-1);
}

int main()
{
	int n;
	cin>>n;
	cout<<f(n)<<endl;
	return 0;
}

// Fibonacci数列
#include<iostream>
using namespace std;

int fibonacci(int n)
{
	if(n == 1 or n == 0) return 1;
	return fibonacci(n-1) + fibonacci(n-2);
}

int main()
{
	int n;
	cin>>n;
	cout<<fibonacci(n)<<endl;
	return 0;
}

3、Ackerman函数

#include<iostream>
using namespace std;

int Ackerman(int m,int n){
	int q;
	if(m == 0)
		return n+1;
	else if(n == 0)
		return Ackerman(m-1,1);
	else{
		return Ackerman(m-1,Ackerman(m,n-1));
	}
}


int main()
{
	int n, m;
	cin>>n>>m;
	cout<<Ackerman(n, m)<<endl;
	return 0;
}

4、整数划分问题

#include<iostream>
using namespace std;

int q(int n, int m)
{
	if (n < 1 or m < 1)  return 0;
	if (n == 1 or m == 1)  return 1;
	if (n < m)  return q(n, n);
	if(n == m)  return 1 + q(n, m-1);
	return q(n, m-1) + q(n - m, m);
}

int main()
{
	int n, m;
	cin>>n>>m;
	cout<<q(n, m)<<endl;
	return 0;
}

xxwl123
关注
西南交通大学算法分析与设计实验报告 - 棋盘覆盖问题.docx
08-11
在一个2^k*2^k个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为特殊方格。棋盘覆盖问题要求下图四种不同形状的L型骨牌覆盖给定棋盘上除特殊方格以外的所有方格，且任意2个L型骨牌不得重叠覆盖。 （仅供参考，请独立完成实验）
算法分析与设计：棋盘覆盖问题（分治法）
SongXJ的博客
01-10 2万+
棋盘覆盖问题 在一个 2k×2k2^{k} \times 2^{k}2k×2k 个方格组成的棋盘中，若恰有一个方格与其他方格不同，则称该方格为特殊方格。显然，特殊方格在棋盘上出现的位置有 4k4^{k}4k 种情形。下图是 k=2k=2k=2 时 16 个特殊棋盘中的一个。 在棋盘覆盖问题中，要用图示的 4 种不同形态的 LLL 型骨牌覆盖一个给定的特殊棋盘上除特殊方格以外的所有方格，且任何 2 个 L\mathrm{L}L 型骨牌不得重叠覆盖。易知，在任何一个 2k×2k2^{k} \times 2^{
算法分析与设计-05-棋盘覆盖问题算法
高行行
11-13 361
棋盘覆盖问题算法： #include int tile=1; int board[100][100]; void ChessBoard(int tr,int tc,int dr,intdc,int size) {          if(size==1)  return;//递归边界          intt=tile++;//L型骨牌号          ints=size/
算法分析 | 分治策略算法设计之棋盘覆盖 C语言版
kndjg的博客
03-12 2851
算法分析 | 分治策略算法设计之棋盘覆盖 C语言版 声明：凡代码问题，欢迎在评论区沟通。承蒙指正，一起成长！
计算机算法设计与分析之棋盘覆盖问题
weixin_33991418的博客
02-14 185
一、引子 近期又又一次上了算法课，如今想来有点汗颜。大学期间已经学习了一个学期。到如今却依旧感觉仅仅是把老师讲过的题目弄懂了，并没有学到算法的一些好的分析方法和思路，碰到一个新的问题后往往感觉非常棘手，痛定思痛之后认为还是好好再学习一遍。争取能理解透彻每种算法的思路和核心，同一时候也劝诫各位同行们做事要脚踏实地，不能应付老师的作业，最后吃亏的还是自己啊。 二、棋盘覆盖问题  ...
算法设计与分析.pdf
02-03
### 算法设计与分析 #### 知识点概览 在《算法设计与分析》这本教材中，作者Dexter C. Kozen详细介绍了算法设计与分析的基础及高级主题，旨在为计算机科学领域的研究生提供全面的学习资源。本书不仅适用于准备博士...
算法设计与分析基础第三版答案
02-26
《算法设计与分析基础》是计算机科学领域的一本经典教材，主要探讨了如何设计和评估算法，以及如何通过数学分析来理解算法的效率。这本书的第三版提供了更深入的算法讲解，涵盖了各种基本的和高级的算法技术。针对你...
算法设计与分析课件 屈婉玲.rar
03-07
《算法设计与分析》是计算机科学领域一门至关重要的课程，主要涵盖了如何设计高效算法以及对算法性能进行分析的理论和实践。屈婉玲教授的这门课件详细讲解了这一主题，旨在帮助学习者深入理解算法的核心概念，提高...
算法设计与分析 棋盘覆盖问题
12-19
c++代码 算法设计与分析 棋盘覆盖问题
算法设计与分析课后习题答案（c++）
06-02
算法设计与分析（第二版）中各章的课后习题 C++代码解答。主要是对 1 - 8章 以及 第10章中的课后习题进行代码解答，主要包括的章节有第1章概论、第2章递归算法设计技术、第3章分治法、第4章蛮力法、第5章回溯法、第6...
计算机算法设计与分析.pdf
04-14
计算机算法设计与分析.pdf 计算机算法设计与分析是计算机科学的核心内容之一，它涉及到算法的设计、分析和实现。本资源提供了计算机算法设计与分析的系统化知识，涵盖了算法设计的基本思想、时间和空间复杂性、图...
【算法设计与分析】 棋盘覆盖问题 递归与分治
weixin_46283740的博客
03-27 857
【算法设计与分析】 棋盘覆盖问题 递归与分治 【问题描述】 使用递归与分治策略解决棋盘覆盖问题 【输入形式】 在屏幕上输入棋盘大小及特殊方格所在行号和列号。 【输出形式】 输出使用L型骨牌进行棋盘覆盖结果。 【样例1输入】 2 1 2 【样例1输出】 2 -1 3 3 2 2 1 3 4 1 1 5 4 4 5 5 【样例说明】 输入：第一行输入整数k表示棋盘大小为2的k次幂，若k为2，则棋盘大小为4行4列；若k为3，则棋盘大小为8行8列。第二行输入特殊方格所在的行号和列号，以空格分隔，当前输入的：1
棋盘覆盖（C语言）
kaizitian的博客
02-06 1690
在一个×个方格组成的棋盘中，恰有一个方格与其他方格不 同，称该方格为“特殊方格”，且称该棋盘为“特殊棋盘”，在棋盘覆盖问题中，要用图1所示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。 本文采用C语言进行编程，并且相信讲解了编程的思想。易懂。
棋盘覆盖问题[算法设计与分析]
不是一切星星 都仅指示黑暗
01-17 2127
实验问题： 用缺了一个格子的正方形去覆盖一个n*n的棋盘，问需要多少个才能覆盖全部棋盘 问题分析： 第一步：可以将棋盘平分为4个象限，然后判定残缺位置落在哪个象限内。 第二步：去填充中间的四个方块中的三个，残缺位置所处的象限的方块不填充。那么问题就转化为四个相同性质的子问题 第三步：顺序处理四个象限，递归实现 数学建模： 建立函数Triomino（r，c，i，j，n） 其中（r，c）是每个象限第一个点，（i，j）是残缺点的坐标，n是棋盘的规模。 第一步：找一个基准格子坐标（n/2,n/2）
算法设计与分析——棋盘覆盖问题
热门推荐
sunshine__0411的博客
11-01 3万+
在一个2^k * 2^k个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。该棋盘为特殊棋盘，蓝色的方格为特殊方格。棋盘覆盖问题是指，要用图2中的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。用分治法设计一个求解棋盘覆盖问题的算法，并且用c++语言实现。思路分析： 第一眼看到这个题目，我是蒙的，除了暴力
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 448
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法设计与分析基础概览
"《算法设计与分析》基础知识周兆熊(整理)" 算法设计与分析是计算机科学中的核心学科，它关注于如何有效地解决问题并分析其效率。这份文档涵盖了该领域的基础知识，适合初学者入门学习。 在算法设计与分析中，算法...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值