北京科技大学 算法分析与设计 计蒜客

已于 2023-01-18 22:21:39 修改
阅读量1.1k 收藏 16
点赞数 4
分类专栏： 其他 文章标签： 算法 c++ 数据结构
于 2023-01-18 21:35:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lsdqyz/article/details/128730293
版权

北京科技大学 算法分析与设计 计蒜客平时作业及实验代码 2022年（仅供参考）

目录

作业一

买房子

[USACO Open08]农场周围的道路

国王的魔镜 

作业二

蜗牛旅游

[NOIP2001]求先序排列

作业三 

二分查找

白菜君的三角形

压缩歌曲

作业四 

踩方格

最长上升子序列

作业五

划分整数

神奇的口袋

作业六

代码填空：全排列

自然数拆分

文具店 

实验

实验一 书架

实验二 封印之门

实验三 银行贷款

实验四 防御导弹

作业一

买房子

//买房子
#include<iostream>
using namespace std;
int main(){
    int N, K;
    cin >> N >> K;
    double price = 200.0;
    double ratio = K * 0.01 + 1;
    int year = 1;
    while(1){
        if(year >= 20){
            cout << "Impossible";
            break;
        }
        if(price - year * N <= 0){
            cout << year;
            break;
        }
        price *= ratio;
        year++;
    }
    return 0;
}

[USACO Open08]农场周围的道路

//[USACO Open08]农场周围的道路
#include<iostream>
using namespace std;

int res;

void MyCount(int N,int K){
    int temp = N - K;
    if( temp <= 0 || temp & 1 == 1){
        res++;
        return;
    }
    else{
        MyCount(temp / 2 + K , K);
        MyCount(temp / 2 , K);
    }
}

int main(){
    res = 0;
    int  N,K;
    cin >> N >> K;
    MyCount(N , K);
    cout << res;
    return 0;
}

国王的魔镜 

//国王的魔镜
#include<iostream>
#include<algorithm>
using namespace std;

int main(){
    string s;
    cin >> s;
    while(1){
        int len = s.size();
        string t = s;
        if( len & 1 == 1){
            cout << len;
            break;
        }            
        reverse(s.begin(), s.end());
        if( t == s) 
            s = t.substr(0, len / 2);
        else{
            cout << s.size();
            break;
        }
    }
    return 0;
}

作业二

蜗牛旅游

//蜗牛旅游
#include<iostream>
#include<vector>
#include<unordered_map>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int>landscape(n);
    for (auto &i : landscape) cin>>i;
    unordered_map<int, int>Map;
    int res = 0;
    int len = 0;
    for (int i = 0; i < n; i++) {
        if (!Map.count(landscape[i])) {
            Map[landscape[i]] = i;
            len++;
        }
        else {
            int t_len = i - Map[landscape[i]];
            if (t_len > len) len++;
            else len = t_len;
            Map[landscape[i]] = i;
        }
        res = max(res,len);
    }
    cout << res;
    return 0;
}

[NOIP2001]求先序排列

//[NOIP2001]求先序排列
#include<iostream>
#include<algorithm>
using namespace std;

void CreatePreorder(string inorder, string post) {
    if (inorder.size() > 0) {
        char now = post.back();
        cout << now;
        int k = inorder.find(now);
        //遍历左子树
        CreatePreorder(inorder.substr(0, k), post.substr(0, k));
        //遍历右子树
        CreatePreorder(inorder.substr(k + 1), post.substr(k, inorder.size() - k - 1));
    }
}

int main() {
    string inorder_string, postorder_string;
    cin >> inorder_string >> postorder_string;
    CreatePreorder(inorder_string, postorder_string);
    return 0;
}

作业三 

二分查找

//二分查找
#include<iostream> 
#include<algorithm>
using namespace std;

int main() {
    std::ios::sync_with_stdio(false);
    cin.tie(0);
	int n, m;
	cin >> n >> m;
    int *arr = new int [n];
	for (int i = 0; i < n; i++) cin >> arr[i];
	sort(arr, arr + n);
    int loc;
    int minN = arr[0];
    int maxN = arr[n-1];
	for(int i = 0; i < m; i++) {
        int t; 
        cin >> t;
        if(t <= minN) {
            cout << -1 << '\n';
            continue;
        }
        if(t > maxN) {
            cout << maxN << '\n';
            continue;
        }
		loc = lower_bound(arr, arr + n, t) - arr;
		if (loc > 0) cout << arr[loc - 1] << '\n';
		else cout << -1 << '\n';
	}
	return 0;
}

白菜君的三角形

//白菜君的三角形
#include<iostream>
using namespace std;

int func(int n) {
    int target = n * n;
    int sum = 0;
    int down = 3;
    int top = n - 1;
    //双指针 慢速收缩
    while (down < top) {
        int now = down * down + top * top;
        if (now < target) down++;
        else if (now > target) {
            top--;
        }
        else {
            sum += down / 2;
            down++;
            top--;
        }
    }
    return sum;
}

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

压缩歌曲

//压缩歌曲
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

typedef long long ll;

int main() {
	ll n, m;
	cin >> n >> m;
	vector<ll>initial(n);
	vector<ll>compress(n);
	vector<ll>difference(n);
	ll minN = 0;
    for(ll i = 0; i < n; i++) {
    	cin >> initial[i] >> compress[i];
    	difference[i] = initial[i] - compress[i];
    	minN += compress[i];
    }
    if(minN > m) cout << -1;
    else if(minN == m) cout << n;
    else {
    	ll leave = m - minN;
        sort(difference.begin(), difference.end());
        //贪心
        for(auto i:difference) {
        	leave -= i;
        	if(leave >= 0) n--;
        }
        cout << n;
    }
	return 0;
}

作业四 

踩方格

// 踩方格
#include<iostream>
using namespace std;

int getNumber(int n) {
	if(n == 0) return 0;
	int north = 1;
	int east_west = 2;
	while(--n) {
		int t_north = east_west + north;
		int t_east_west = north * 2 + east_west;
		north = t_north;
		east_west = t_east_west;
	}
	return north + east_west;
} 

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

最长上升子序列

// 最长上升子序列
#include<iostream>
#include<string>
#include<algorithm> 
#include<cmath> 
using namespace std; 

const int N = 1e5 + 10; 

struct Lsh {
    int id;
    int value; 
} lis[N];

int a[N], LIS, n;

int t[N], arr1[N], arr2[N], num[N]; 

inline bool cmp(Lsh x, Lsh y){
    return x.value < y.value; 
}

int main() {
	std::ios::sync_with_stdio(false);
    cin.tie(0);
    freopen("lis.in", "r", stdin); 
    freopen("lis.out","w", stdout); 
    cin >> n;
    for(int i= 1; i <= n; i++) {
        cin >> lis[i].value;
        lis[i].id = i;
    }
    sort(lis + 1, lis + 1 + n, cmp);
    
    int index = 0;
    lis[0].value = -1;
    
    for (int i = 1; i <= n; i++) {
        if(lis[i].value != lis[i - 1].value) index++;
        a[lis[i].id] = index;
    }

    for(int i = 0; i < N; i++) t[i] = 2147483647;
    t[0] = 0;

    for (int i = 1; i <= n; i++) {
        arr1[i] = lower_bound(t + 1, t + 1 + n, a[i]) - t;
        t[arr1[i]] = a[i];
        LIS = max(LIS, arr1[i]);
    }

    for(int i = 0; i < N; i++) t[i] = 2147483647;
    t[0] = 0;
    
    for (int i = n; i >= 0; i--) {
        arr2[i] = lower_bound(t + 1, t + 1 + n, -a[i]) - t; 
        t[arr2[i]] = -a[i];
    }
    
    for(int i= 1; i <= n; i++) {
        if(arr1[i] + arr2[i] == LIS + 1)
            num[arr1[i]]++;
    }
    
    for (int i = 1; i <=n; i++) {
        if(arr1[i] + arr2[i] == LIS + 1 && num[arr1[i]] ==1) 
            cout << LIS - 1 << ' ';
        else
            cout << LIS << ' '; 
    }
}

作业五

划分整数

// 划分整数
#include<iostream>
#include<vector>
using namespace std;

typedef long long ll;
    
ll getNumber(int n, int m) {
	if(m == 1) return 1;
	vector<vector<ll>>dp(n + 1, vector<ll>(m + 1));
	for(int i = 1; i <= n; i++) {
		for(int j = 1; j <= m; j++) {
            if(i == 1 || j == 1) dp[i][j] = 1;
            else if(j > i) dp[i][j] = dp[i][i];
            else if(i == j) {
                dp[i][j] = dp[i][j - 1] + 1;
            }
            else {
                dp[i][j] = dp[i][j - 1] + dp[i - j][j];
            }
		}
	}
	return dp[n][m];
}

int main() {
	int n, k;
	cin >> n >> k;
    cout << getNumber(n, k);
    return 0;
}

神奇的口袋

// 神奇的口袋
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

typedef long long ll;
#define RG register
#define MAX 1111

inline int read() {
	RG int x = 0, t = 1;
	RG char ch = getchar();
	while ((ch < '0' || ch>'9') && ch != '-') ch = getchar();
	if (ch == '-') {
		t = -1;
		ch = getchar();
	}
	while (ch <= '9' && ch >= '0') {
		x = x * 10 + ch - 48;
		ch = getchar();
	}
	return x * t;
}

struct BigInt {
	int s[20000], ws;
	void init() {
		s[1] = 1;
		ws = 1;
	}
	void Multi(int x) {
		for (int i = 1; i <= ws; ++i) s[i] = s[i] * x;
		for (int i = 1; i <= ws; ++i) {
			s[i + 1] += s[i] / 10;
			s[i] %= 10;
		}
		while (s[ws + 1]) {
			++ws;
			s[ws + 1] = s[ws] / 10;
			s[ws] %= 10;
		}
	}
	void output() {
		for (int i = ws; i; --i)
			printf("%d", s[i]);
	}
}Ans1, Ans2;

int pri[20001], tot;
bool zs[20001];

void getpri() {
	zs[1] = true;
	for (int i = 2; i <= 20000; ++i) {
		if (!zs[i]) pri[++tot] = i;
		for (int j = 1; j <= tot && i * pri[j] <= 20000; ++j) {
			zs[i * pri[j]] = true;
			if (i % pri[j] == 0)break;
		}
	}
}

int Mul[20001], Div[20001];
int sum, a[MAX];
int n, m, D;

void Calc(int x, int* f) {
	for (int i = 1; i <= tot; ++i) {
		while (x % pri[i] == 0) {
			f[pri[i]]++;
			x /= pri[i];
		}
	}
}

int main() {
	n = read();
	m = read();
	D = read();
	for (int i = 1; i <= n; ++i) {
		a[i] = read();
		sum += a[i];
	}
	getpri();
	for (int i = 1; i <= m; ++i) {
		int x = read(), y = read();
		if (!a[y]) {
			puts("0/1");
			return 0;
		}
		Calc(a[y], Mul);
		Calc(sum, Div);
		a[y] += D;
		sum += D;
	}
	for (int i = 1; i <= 20000; ++i) {
		if (Div[i] >= Mul[i]) {
			Div[i] -= Mul[i];
			Mul[i] = 0;
		}
		else {
			Mul[i] -= Div[i];
			Div[i] = 0;
		}
	}
	Ans1.init();
	Ans2.init();
	for (int i = 1; i <= 20000; ++i)
		for (int j = 1; j <= Mul[i]; ++j)
			Ans1.Multi(i);
	for (int i = 1; i <= 20000; ++i)
		for (int j = 1; j <= Div[i]; ++j)
			Ans2.Multi(i);
	Ans1.output();
	putchar('/');
	Ans2.output();
	puts("");
	return 0;
}

作业六

代码填空：全排列

// 代码填空：全排列
vis[j] && str[i] == str[j]

自然数拆分

// 自然数拆分
#include<iostream>
#include<vector>
using namespace std;

vector<int>matrix(20);
int n, m;

void dfs(int num, int init, int sum) {
	if(sum == n) {
        cout << n << "=";
		for(int i = 1; i <= num - 1; i++) {
			cout << matrix[i];
			if(i != num - 1)
				cout << "+";
		}
		cout << "\n";
		return;
	}
    if(sum + init > n) return;
	for(int i = init; i <= n - 1; i++) {		
		if(sum + i <= n) {
			matrix[num] = i;
			dfs(num + 1, i, sum + i);
		}
	}
}

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

文具店 

// 文具店
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

typedef long long ll;

void dfs(string s, int k, ll t, ll &res) {
	if(k == 1) {
        ll tmp = 0;
		for(auto i : s) tmp =  tmp * 10 + i - '0';
		res = min(t + tmp, res);
		return;
	}
	if(s.size() <= k) {
		for(auto i : s) t += i - '0';
		res = min(t, res);
		return;
	}
	ll tmp = 0;
	for(int i = 0; i + k - 1 < s.size(); i++) {
		tmp = tmp * 10 + s[i] - '0';
		dfs(s.substr(i + 1), k - 1, t + tmp, res);
	}
}

ll Mycount(string s, int k) {
	ll res = 0;
	// 字符串长度与水彩笔数相等
	if(s.size() == k) {
		for(auto i : s) res += i - '0';
		return res;
	}
	res = 1e9;
	dfs(s, k, 0, res);
	return res;
}

int main() {
	string s;
	int k;
	cin >> s >> k;
    cout << Mycount(s, k);
    return 0;
}

实验

实验一 书架

// 书架
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;

int main() {
	int n;
	int target;
	cin >> n >> target;
	vector<int>cows(n);
	for(auto &i: cows) cin >> i;
	sort(cows.begin(), cows.end(), greater<int>());
	int count_num = 0;
	while(target > 0) {
		target -= cows[count_num];
		count_num++;
	}
	cout << count_num;
	return 0;
}

实验二 封印之门

本题要求使用回溯法解题，但实际上使用 Dijkstra 或 Floyd 算法更好

Floyd算法：

// Floyd 算法
#include<iostream>
#include<vector>
using namespace std;

#define MAXN 26

vector<vector<int>>shortPath(MAXN, vector<int>(MAXN, MAXN)); // 各顶点间的最短距离

int main() {
	string initial;
	string target;
	int n;
	cin >> initial >> target >> n;
	for(int i = 0; i < MAXN; i++) shortPath[i][i] = 0;
	for(int i = 0; i < n; i++) {
		char a, b;
		cin >> a >> b;
		if(a == b) continue;
		shortPath[a - 'a'][b - 'a'] = 1;
	}
    
    for(int i = 0; i < MAXN; i++) {
        for(int j = 0 ; j < MAXN; j++) {
            for(int k =0; k < MAXN; k++) {
                // 更新最小路径
                if(shortPath[j][k] > shortPath[j][i] + shortPath[i][k]){         
                    shortPath[j][k] = shortPath[j][i] + shortPath[i][k];  
                }
            }
        }
    }
    
    int res = 0;
    int len = initial.size();
    for(int i = 0; i < len; i++) {
    	if(initial[i] != target[i]) {
    		int a = initial[i] - 'a';
    		int b = target[i] - 'a';
    		if(shortPath[a][b] == MAXN) {
    		    res = -1;
    		    break;
    		}
    		else res += shortPath[a][b];
    	}
    }
    cout << res;
	return 0;
}

回溯法： 

// 回溯 
// 有一个用例一直过不了，鉴定为恶心人
// 下列代码仍可优化，有兴趣可以试试
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

#define MAXN 26

int shortPath[MAXN][MAXN]; // 各顶点间的最短距离

void dfs(int init, int target, int now, int num) {
	if(now == target) {
		shortPath[init][target] = min(shortPath[init][target], num);
		return;
	}
	// 剪枝: 超过目前 shortPath[init][target] 必不可能产生新的最小值
	if(num >= shortPath[init][target]) return;
	// 剪枝: shortPath[now][target] 最短路径存在直接使用
	if(shortPath[now][target] < MAXN) {
		if(shortPath[init][target] > num + shortPath[now][target])
		    shortPath[init][target] = num + shortPath[now][target];
		return;
	}
	for(int i = 0; i < MAXN; i++) {
	    if(now != i && shortPath[now][i] < MAXN) {
	    	dfs(init, target, i, num + shortPath[now][i]);
	    }
	}
}

int main() {
    std::ios::sync_with_stdio(false);
    cin.tie(0);
	string initial;
	string target;
	int k;
	cin >> initial >> target;
	cin >> k;
	for(int i = 0; i < MAXN; i++) {
		for(int j = 0; j < MAXN; j++) {
	        if(i == j) shortPath[i][j] = 0;
	        else shortPath[i][j] = MAXN;
	    }
	}
	for(int i = 0; i < k; i++) {
		char a, b;
		cin >> a >> b;
		if(a == b) continue;
		shortPath[a - 'a'][b - 'a'] = 1;
	}
	for(int i = 0; i < MAXN; i++) {
		for(int j = 0; j < MAXN; j++) {
			// 相等或路径已存在则无需继续寻找
			if(i == j || shortPath[i][j] < MAXN) continue;
            else {
            	dfs(i, j, i, 0);
            }
		}
	}
	int res = 0;
	int len = initial.size();
	for(int i = 0; i < len; i++) {
		// 相等无需操作，跳过
		if(initial[i] == target[i]) continue;
		int a = initial[i] - 'a';
		int b = target[i] - 'a';
		// 无法操作，退出循环，输出 -1
        if(shortPath[a][b] == 26) {
            res = -1;
            break;
        }
		res += shortPath[a][b];
	}
	cout << res;
	return 0;
}

实验三 银行贷款

// 银行贷款
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <cmath>
using namespace std;

bool check(int x, int y, int n, double mid) {
	double t = 0.0;
	for (int i = 1; i <= n; i++) {
		t += (double)(y / pow(mid, i));
	}
	if (t > x) return true;
	else return false;
}

double half_search(int x, int y, int n) {
	if (x == n * y) return 1.0;
	double left = 1.0;
	double right = 11.0;
	double mid = 0.0;
	double precision = 1e-4;
	while (right - left > precision) {
		mid = (right - left) / 2.0 + left;
		if (check(x, y, n, mid)) left = mid;
		else right = mid;
	}
	return left;
}

int main() {
	int x, y, n;
	cin >> x >> y >> n;
	cout << fixed;
	cout << setprecision(1) << (half_search(x, y, n) - 1.0) * 100;
	return 0;
}

实验四 防御导弹

动态规划：

// 动态规划
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int>missiles(n);
    vector<int>dp(n);
    for(int i = 0; i < n; i++) {
        cin >> missiles[i];
    }
    int res = 0;
    for(int i = 0; i < n; i++) {
    	dp[i] = 1;
    	for(int j = 0; j < i; j++) {
    		if(missiles[j] < missiles[i]) {
    			dp[i] = max(dp[i], dp[j] + 1);
    		}
    	}
    	res = max(res, dp[i]);
    }
    cout << res;
    return 0;
}

模拟： 

// 模拟
#include<iostream>
#include<vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int>missiles(n);
    vector<int>systems;
    for(int i = 0; i < n; i++) {
        cin >> missiles[i];
    }
    for(int i = 0; i < n; i++) {
    	int high = 30001;
        int index = -1;
    	int len = systems.size();
    	for(int j = 0; j < len; j++) {
    		if(systems[j] >= missiles[i] && systems[j] < high) {
                high = systems[j];
    			index = j;
    		}
    	}
    	if(index == -1) systems.emplace_back(missiles[i]);
    	else systems[index] = missiles[i];
    }
    cout << systems.size();
    return 0;
}

零时的轻语者
关注
专栏目录
程振波 算法设计与分析_算法设计与分析
weixin_39747341的博客
12-21 1438
本书按照教育部*制定的计算机科学与技术专业规范的教学大纲编写，努力与国际计算机学科的教学要求接轨。强调 算法 与 数据结构 之间密不可分的联系，因而强调融数据类型与定义在该类型上的运算于一体的抽象数据类型，为面向对象的程序设计方法奠定基础，体现计算机科学方法论的理论、抽象和设计三个过程，知识面较宽，且有一定的深度；反复再现计算机科学中用到的大问题的复杂性、效率、抽象的层次、重用、折衷等带有普遍性的...
怎样读懂计算机论文算法,最新计算机算法分析论文参考文献 计算机算法分析专著类参考文献有哪些...
weixin_35619710的博客
07-10 988
【100个】最新计算机算法分析论文参考文献供您参考,希望能解决毕业生们的计算机算法分析专著类参考文献有哪些相关问题,整理好参考文献那就开始写计算机算法分析论文吧！一、计算机算法分析论文参考文献范文[1]CAD在乳腺影像中的应用.秦乃姗，2011中华医学会放射学分会第三届全国乳腺学术会议暨长安医学影像论坛[7]复杂背景下的运动目标鲁棒检测算法.丁莹.李文辉.范静涛.杨华民，2009第六届智能CAD与...
2021-USTB-数据结构实验 (计蒜客)
06-29
计蒜客综合实验 仅供参考，切勿抄袭 Work 1 - 公司管理系统 Work 2 - 文本编辑程序 Work 3 - 文学作品分析 Work 4 - 滤镜功能 Work 5 - 排位系统 Work 6 - 高速路网设计
计蒜客第三场 -- A 腾讯课堂的物理实验
chuangjin1715的博客
05-28 260
在腾讯课堂的物理课上，进行了一个有趣的物理实验。 在一个长度为LL米的光滑轨道上，小车 A 在00时刻以1\mathrm{m/s}1m/s的速度从左端出发向右运动，小车 B 在tt时刻以1\mathrm{m/s}1m/s的速度从右端出发向左运动，两个小车的质量相等。假设所...
北京科技大学 USTB 数据结构 计蒜客平台 全部章节作业
07-04
（本资源完全免费） 资源如题 是VScode中直接搬过来的，所以包括了exe文件，VScode直接用需要改json配置
计蒜客-炮台实验
。
02-14 239
蒜头君在玩一个战争模拟游戏，他有高度为 1,2,3,\ldots ,n1,2,3,…,n 的炮台各一个，他需要把这 nn个炮台从左往右排成一行，并且炮口都朝向右边。 在这个游戏中，所有炮台发射的炮弹会摧毁前方所有高度比自己低的炮台。每当蒜头君把 nn个炮台排成一行后，可能会有一些炮台被摧毁。举个例子：当前有 55 个炮台，从左到右高度分别为 2,1,3,5,42,1,3,5,4，往右发射炮弹后，...
Week13 实验 C - 2-T1 计蒜客 - T1189
ziseon的博客
05-26 119
东东对数字很敏感，他定义了一个数的数根，数根即把一个数的各个位上的数字加起来可以得到。如果得到的数是一位数，那么这个数就是数根。如果结果是两位数或者包括更多位的数字，那么再把这些数字加起来。如此进行下去，直到得到是一位数为止。 比如，对于 242424 来说，把 222 和 444 相加得到 666，由于 666 是一位数，因此 666 是 242424 的数根。再比如 393939，把 333 和 999 加起来得到 121212，由于 121212 不是一位数，因此还得把 111 和 222 加起来，最
北京邮电大学算法设计与分析编程作业.zip
02-28
总的来说，北京邮电大学的这份算法设计与分析编程作业不仅锻炼了学生的编程技巧，更让他们深入理解了算法设计的原则和分析方法，为未来在信息科技领域的工作或研究打下了坚实的基础。通过反复实践和思考，学生们将...
国科大-算法设计与分析-卜东波-2018-2019 期末考试试卷- 高清文字可复制
02-27
### 国科大-算法设计与分析-卜东波-2018-2019 期末考试试卷- 高清文字可复制 #### Divide and Conquer (14) **题目**: 给定一棵二叉树 T，请给出一个 O(n) 的算法来反转二叉树。 **示例**: 下面的示例展示了将...
北京邮电大学计算机科学与技术大三算法设计与分析.zip
10-23
《北京邮电大学计算机科学与技术大三算法设计与分析》 在计算机科学与技术领域，算法设计与分析是至关重要的部分，它涉及到如何高效地解决问题以及评估解决方案的效率。北京邮电大学作为国内信息科技领域的顶尖学府...
计蒜客（三）内存管理与地址转换
发现问题，并解决问题，批判性思维
01-31 654
1.内存管理的基本思想 1 2.蒜头均的内存管理方法 1 3.连续内存管理 1 4.可变分区存储管理的实现 1 5.内存不足的解决方法 1 6.固定分区与可变分区对比 1 7.分段内存管理 1 8.分段存储管理与分页与分段的结合 1 9.分页与分段 1 10.一个数学问题 1 11.虚拟存储，多级页表与反置页表 1 12.地址转化总...
计蒜客 - T2063_导弹拦截
这题AC再睡
02-13 743
计蒜客 - T2063_导弹拦截
国王的魔镜
pandawen123的博客
11-30 410
对称的魔镜 镜子找出来的数字顺序应该对此且为轴对称，然后根据题目意思求解。
国王的魔镜|题解
Y_bluefat的博客
04-18 2511
原创不易 转发请标明出处
【滨小之旅递归】国王的魔镜
鹭天
07-12 258
国王有一个魔镜，可以把任何接触镜面的东西变成原来的两倍——只是，因为是镜子嘛，增加的那部分是反的。比如一条项链，我们用AB来表示，不同的字母表示不同颜色的珍珠。如果把B端接触镜面的话，魔镜会把这条项链变为ABBA。如果再用一端接触的话，则会变成ABBAABBA（假定国王只用项链的某一端接触魔镜）。给定最终的项链，请编写程序输出国王没使用魔镜之前，最初的项链可能的最小长度。
【洛谷】国王的魔镜
balbalbalabl的博客
12-01 391
回文数判断。
洛谷P2799 国王的魔镜 题解
最新发布
Win_slow的博客
03-30 319
《国王的墨镜》
T1725 国王的魔镜——dfs
与其邻渊羡渔，不如退而结网
09-25 262
【代码】T1725 国王的魔镜——dfs。
JAVA蓝图工具实践：算法与程序设计入门
"《算法与程序设计实践》是一本针对北京信息科技大学计算机学院软件工程系的教材，主要关注于算法与程序设计的教学和实践。本书以实验的形式引导学生掌握核心技能，包括工具基本使用、程序概念模型设计、逻辑模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值