二刷算法基础题DAY6

2. 01背包问题
   题目链接

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

const int N=1000;

int n,v;
int z[N+10];
int val[N+10];
int f[N+10][N+10];

int main(){
    cin>>n>>v;
    for(int i=1;i<=n;i++){
        cin>>z[i]>>val[i];
    }
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=v;j++){
            f[i][j]=f[i-1][j];
            if(z[i]<=j)  f[i][j]=max(f[i-1][j],f[i-1][j-z[i]]+val[i]);
        }
    }
    cout<<f[n][v];
    return 0;
}

3. 完全背包问题
   题目链接

虽然超时，但是思路是对的

#include<iostream>
using namespace std;

const int N = 1010;

int n, m;
int dp[N][N], v[N], w[N];

int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; i ++ )
        cin >> v[i] >> w[i];

    for(int i = 1; i <= n; i ++ )
        for(int j = 0; j <= m; j ++ )
            for(int k = 0; k * v[i] <= j; k ++ )
                dp[i][j] = max(dp[i][j], dp[i - 1][j - k * v[i]] + k * w[i]);
    cout << dp[n][m] << endl;
}

4. 多重背包问题 I
   题目链接

#include <iostream>
#include <algorithm>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int dp[1010],a1[1010],a2[1010],a3[1010];


int main(int argc, char *argv[]) {
	int n,v;
	cin>>n>>v;
	for(int i=0;i<n;i++)
	{
		cin>>a1[i]>>a2[i]>>a3[i];
	}
	
	for(int i=0;i<n;i++)
	{
		for(int j=v;j>=0;j--)
		{
			for(int k=0;k<=a3[i];k++)
			{
				if(j>=k*a1[i])
				{
					dp[j]=max(dp[j],dp[j-k*a1[i]]+k*a2[i]);
				}
			}
		}
		
		
	}
	cout<<dp[v];

	return 0;
}

516. 最长回文子序列
     题目链接

做一个reverse，转换成s1 s2做一个最长公共子序列问题。

class Solution {
public:
    int longestPalindromeSubseq(string s1) {
        string  s2 = s1;
        reverse(s2.begin(), s2.end());//s2为s1的逆序列
        return longestCommonSubsequence(s1,s2);
    }
    
    //最长公共子序列函数
    int longestCommonSubsequence(string s1, string s2) {
       	int l1 = s1.size(),l2=s2.size();
        int **dp = new int*[l1+1];
            for (int i = 0; i < l1+1; ++i) {
                    dp[i] = new int[l2+1]();
            }
        for (int i = 1; i < l1+1; i++) {
            for (int j = 1; j < l2+1; 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]);
            }
        }
        return dp[l1][l2];
    }
};

1222. 密码脱落
      题目链接

只要分析出来是最长公共子序列问题即可

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
 
const int N=1000+10;
string s;

//最长公共子序列函数
int longestCommonSubsequence(string s1, string s2) {
   	int l1 = s1.size(),l2=s2.size();
    int **dp = new int*[l1+1];
        for (int i = 0; i < l1+1; ++i) {
                dp[i] = new int[l2+1]();
        }
    for (int i = 1; i < l1+1; i++) {
        for (int j = 1; j < l2+1; 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]);
        }
    }
    return dp[l1][l2];
}

int longestPalindromeSubseq(string s1) {
        string  s2 = s1;
        reverse(s2.begin(), s2.end());//s2为s1的逆序列
        return longestCommonSubsequence(s1,s2);
    }

int main(){
   cin>>s;
   cout<<s.size()-longestPalindromeSubseq(s);
    
    return 0;
}    

蓝桥杯模拟赛J题。

J 题:
问题描述
　　2015年，全中国实现了户户通电。作为一名电力建设者，小明正在帮助一带一路上的国家通电。
　　这一次，小明要帮助 n 个村庄通电，其中 1 号村庄正好可以建立一个发电站，所发的电足够所有村庄使用。
　　现在，这 n 个村庄之间都没有电线相连，小明主要要做的是架设电线连接这些村庄，使得所有村庄都直接或间接的与发电站相通。
　　小明测量了所有村庄的位置（坐标）和高度，如果要连接两个村庄，小明需要花费两个村庄之间的坐标距离加上高度差的平方，形式化描述为坐标为 (x_1, y_1) 高度为 h_1 的村庄与坐标为 (x_2, y_2) 高度为 h_2 的村庄之间连接的费用为
　　sqrt((x_1-x_2)(x_1-x_2)+(y_1-y_2)(y_1-y_2))+(h_1-h_2)*(h_1-h_2)。
　　在上式中 sqrt 表示取括号内的平方根。请注意括号的位置，高度的计算方式与横纵坐标的计算方式不同。
　　由于经费有限，请帮助小明计算他至少要花费多少费用才能使这 n 个村庄都通电。
输入格式
　　输入的第一行包含一个整数 n ，表示村庄的数量。
　　接下来 n 行，每个三个整数 x, y, h，分别表示一个村庄的横、纵坐标和高度，其中第一个村庄可以建立发电站。
输出格式
　　输出一行，包含一个实数，四舍五入保留 2 位小数，表示答案。
样例输入
4
1 1 3
9 9 7
8 8 6
4 5 4
样例输出
17.41
评测用例规模与约定
　　对于 30% 的评测用例，1 <= n <= 10；
　　对于 60% 的评测用例，1 <= n <= 100；
　　对于所有评测用例，1 <= n <= 1000，0 <= x, y, h <= 10000。

#include <iostream>
#include<algorithm>
using namespace std;
const int N = 1000;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Vex {
	int x;
	int y;
	int h;
};

Vex vex[N];

struct EDGE {
	int u, v;
	double cost;
	void set(int a, int b, double w) {
		u = a;
		v = b;
		cost = w;
	}
};

EDGE edge[N * N - 1 / 2];

bool cmp(EDGE a, EDGE b) {
	return a.cost < b.cost;
}

int father[N];

int find(int x) {
	if (father[x] == -1) {
		return x;
	}
	else {
		return father[x] = find(father[x]);
	}
}

bool union1(int x, int y) {
	x = find(x);
	y = find(y);
	if (x == y) {
		return false;
	}
	if (x > y) {
		father[x] = y;
	}
	else {
		father[y] = x;
	}
	return true;
}

int main(int argc, char* argv[]) {
	int i;
	int n;
	int v, w;
	double cost;
	int m, t;
	cin >> n;

	//输入的为点集，用kruscal需要转化为边集
	for (int i = 0; i < n;i++) {
		cin >> vex[i].x >> vex[i].y >> vex[i].h;
	}
	int en=0;
	for (int i = 0; i < n - 1;i++) {
		for (int j = i + 1; j < n;j++) {
			edge[en++].set(i, j, sqrt((vex[i].x - vex[j].x)*(vex[i].x - vex[j].x) + (vex[i].y - vex[j].y)*(vex[i].y - vex[j].y)) + (vex[i].h - vex[j].h) * (vex[i].h - vex[j].h));
		}
	}

	sort(edge, edge + en, cmp);
	i = 0;
	fill(father, father + n, -1);
	double sum = 0, count = 0;
	while (count != n - 1) {
		if (union1(edge[i].u, edge[i].v)) {
			cout << edge[i].u << "-" << edge[i].v << endl;
			sum += edge[i].cost;
			count++;
		}
		i++;
	}
	cout << "sum:" << sum << endl;
	return 0;
}