ACM暑假补题 | 2023.7.4——2023.7.5

Rabbit_Ranger

已于 2023-07-09 14:14:20 修改

阅读量111

点赞数

文章标签：算法 c++

于 2023-07-09 11:20:15 首次发布

本文链接：https://blog.csdn.net/Jymer/article/details/131591927

版权

拖好久了，废话不多说开整：

7.4牛客排位

补题1：C-Unique Value

补题2：D-Gone Fishing（计算几何）

补题3：E-Sum of a Function（区间筛+欧拉筛+组合数学）

7.5牛客排位

补题1：D Food Display Arrangement（贪心）

补题2：E Making Connections（并查集）

补题3：F Boxing Books（DP）

补题4：G Bad Tree（二进制）

7.4牛客排位

补题1：C-Unique Value

题意

给定一维数组（可能含重复的数字），求出有多少个不包含重复数字的连续子序列。

思路

搞一个一维数组P，P[i]表示以i下标为开头的新数组有多少个；因为是【连续的】，所以以该位置为开头能到达的最大长度 == 以该位置为开头的子序列数量。最后结果在遍历P即可。

更新P的方法，从后往前更新：该位置的最大值 = min(下一位置的最大值+1, 该位置数字与后面重复的数字的长度)，具体见代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e5+10;
int n;
map<int, int> mp;//1e18太大了，只能用map来处理，负责更新某一数字的最新出现的位置（后到前）
int Arr[N], P[N];//存放原数组；存放i下标为新数组起始位置有多少种连续子序列。

signed main() {
	
	ios::sync_with_stdio(0);
	cout.tie(0); cin.tie(0);
	
	cin >> n;
	for(int i = 1; i <= n; i++) {
		cin >> Arr[i];
	}
	
	for(int i = n; i >= 0; i--) {//从后往前推
		if(mp[Arr[i]] == 0) {//新数字，后面一定没有重复数字
			if(i != n && P[i+1] != 1e18) {//最后一位一定没有重复；
                //传递性：如果后一位有冲突了，那么该位置的最大长度=后一位的最长长度+1；
				P[i] = P[i+1]+1;
				mp[Arr[i]] = i;
			}
			else {//负责就一直表示无重复。mp[Arr[i]] = i 为更新Arr[i]的数字从后往前最早出现的位置。
				P[i] = 1e18;
				mp[Arr[i]] = i;
			}
		}
		else {//已经出现过的数字，则从【后一位的最大长度+1】和【两个重复的数字之间的距离】中取最小值
			P[i] = min(P[i+1]+1, mp[Arr[i]]-i+1);
			mp[Arr[i]] = i;
		}
	}
	
//	for(int i = 1; i <= n; i++) {
//		if(P[i] == 1e18) {
//			cout << "X ";
//		}
//		else {
//			cout << P[i]-1 << " ";
//		}
//	}
//	cout << "\n";
//	
//	for(int i = 1; i <= n; i++) {
//		cout << n-i+1 << " ";
//	}
//	cout << "\n";
	
	int res = 0;
	for(int i = 1; i <= n; i++) {
		res += min(P[i]-1, n-i+1);
        //处于n位的数字后面，没有重复值但受限于位置，最大长度只能为1，所以需要堆n-i+1做一个最小值判断
    
	}
	cout << res << "\n";
}

（打印出来的效果如图⬆）

补题2：D-Gone Fishing（计算几何）

题意

在二维平面的海里，有n个鱼的位置（给出x，y），用一张半径为r的网，求一次可以捕获到的鱼的最大数量。

思路

取任意两点求出圆心的位置，然后再求出每个圆与其它点的距离是否小于半径以此来求出该圆能包含的最大值。

（但是哥们不会写呜呜呜呜计算几何的题，直接上代码吧✌︎〔ツ〕ɔ）

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

int r, n;
struct Point{
	double x, y;
	Point(){};//不知道有啥用，但是很重要（默认的无参构造？）
	Point(double tx, double ty) {//带参构造；
		x = tx, y = ty;
	}
}p[220];

double dist(Point p1,Point p2)//求两点距离 
{
	return sqrt(pow(p1.x-p2.x,2)+pow(p1.y-p2.y,2));///求出两点距离
}

Point circle_center(Point p1, Point p2) {//求圆心位置
	
	Point mid = Point((p1.x+p2.x)/2, (p1.y+p2.y)/2);//先求两点之间的中点位置（理解）
	
	double angle = atan2(p1.x-p2.x, p2.y-p1.y);//求两点的极坐标（不理解：atan2（p1.x-p2.x, p2.y-p1.y））;
	
	double d = sqrt(r*r-pow(dist(p1, mid), 2));//正弦定理求圆心到中点的距离（理解）
	
	return Point(mid.x+d*cos(angle), mid.y+d*sin(angle)); //通过三角函数的知识，求出圆心位置（半理解）
	
}

signed main() {
	cin >> r >> n;
	for(int i = 1; i <= n; i++) {
		cin >> p[i].x >> p[i].y;
	}
	
    int res = 1;//最差情况就是1，不会出现【空军】的情况。
    
	for(int i =1; i <= n; i++) {
		for(int j = i+1; j <= n; j++) {
			
			if(dist(p[i], p[j]) > 2.0*r) continue;//容易遗漏的情况：当两个点都构成不了半径为r的圆时continue。
			
			Point circle = circle_center(p[i], p[j]);
			//printf("circle : x:%f y:%f\n", circle.x, circle.y);
			
			int cnt = 0;
			for(int k = 1; k <= n; k++) {
				//printf("dist = %f,    r = %f \n", dist(circle, p[k]), 1.0*r+1e-6);
				if(dist(circle,p[k])< 1.0*r+1e-6 ) {
					cnt++;
				}
			}
			//cout << cnt << "\n";
			
			res = max(res, cnt);
		}
	}
	
	cout << res << "\n";
}

其实还是有点不理解的地方，比如两点能确定两个圆心但是，为什么只对其中一个作了判断呢？八成又是什么对称、容斥定理啥的？

补题3：E-Sum of a Function（区间筛+欧拉筛+组合数学）

题意

定义函数f(x)求得x的最小素数因子，在数字s到数字e的范围（包括s和e），累加从小到大排列的前k个因子，输出累加和。（s和e最大相差1e6）

分析

因为数量级问题，不能开循环在s到e之间挨个循环（因为我已经试过，WA了一发(╯▔皿▔)╯）所以我才用的是先将“足量”的素数打印出来，这样找x的最小素数因子时就快一点，最后卡过去了。代码如下：

//为有牺牲多壮志，敢教日月换新天。
#include <bits/stdc++.h>
using namespace std;
#define int long long

int s, e, k;
const int N = 2e3, N1 = 1e6+10; 
//打表出质数先✌︎〔ツ〕ɔ；
int P[N] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597,1601,1607,1609,1613,1619,1621,1627,1637,1657,1663,1667,1669,1693,1697,1699,1709,1721,1723,1733,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811,1823,1831,1847,1861,1867,1871,1873,1877,1879,1889,1901,1907,1913,1931,1933,1949,1951,1973,1979,1987,1993,1997,1999,2003,2011,2017,2027,2029,2039,2053,2063,2069,2081,2083,2087,2089,2099,2111,2113,2129,2131,2137,2141,2143,2153,2161,2179,2203,2207,2213,2221,2237,2239,2243,2251,2267,2269,2273,2281,2287,2293,2297,2309,2311,2333,2339,2341,2347,2351,2357,2371,2377,2381,2383,2389,2393,2399,2411,2417,2423,2437,2441,2447,2459,2467,2473,2477,2503,2521,2531,2539,2543,2549,2551,2557,2579,2591,2593,2609,2617,2621,2633,2647,2657,2659,2663,2671,2677,2683,2687,2689,2693,2699,2707,2711,2713,2719,2729,2731,2741,2749,2753,2767,2777,2789,2791,2797,2801,2803,2819,2833,2837,2843,2851,2857,2861,2879,2887,2897,2903,2909,2917,2927,2939,2953,2957,2963,2969,2971,2999,3001,3011,3019,3023,3037,3041,3049,3061,3067,3079,3083,3089,3109,3119,3121,3137,3163,3167,3169,3181,3187,3191,3203,3209,3217,3221,3229,3251,3253,3257,3259,3271,3299,3301,3307,3313,3319,3323,3329,3331,3343,3347,3359,3361,3371,3373,3389,3391,3407,3413,3433,3449,3457,3461,3463,3467,3469,3491,3499,3511,3517,3527,3529,3533,3539,3541,3547,3557,3559,3571,3581,3583,3593,3607,3613,3617,3623,3631,3637,3643,3659,3671,3673,3677,3691,3697,3701,3709,3719,3727,3733,3739,3761,3767,3769,3779,3793,3797,3803,3821,3823,3833,3847,3851,3853,3863,3877,3881,3889,3907,3911,3917,3919,3923,3929,3931,3943,3947,3967,3989,4001,4003,4007,4013,4019,4021,4027,4049,4051,4057,4073,4079,4091,4093,4099,4111,4127,4129,4133,4139,4153,4157,4159,4177,4201,4211,4217,4219,4229,4231,4241,4243,4253,4259,4261,4271,4273,4283,4289,4297,4327,4337,4339,4349,4357,4363,4373,4391,4397,4409,4421,4423,4441,4447,4451,4457,4463,4481,4483,4493,4507,4513,4517,4519,4523,4547,4549,4561,4567,4583,4591,4597,4603,4621,4637,4639,4643,4649,4651,4657,4663,4673,4679,4691,4703,4721,4723,4729,4733,4751,4759,4783,4787,4789,4793,4799,4801,4813,4817,4831,4861,4871,4877,4889,4903,4909,4919,4931,4933,4937,4943,4951,4957,4967,4969,4973,4987,4993,4999,5003,5009,5011,5021,5023,5039,5051,5059,5077,5081,5087,5099,5101,5107,5113,5119,5147,5153,5167,5171,5179,5189,5197,5209,5227,5231,5233,5237,5261,5273,5279,5281,5297,5303,5309,5323,5333,5347,5351,5381,5387,5393,5399,5407,5413,5417,5419,5431,5437,5441,5443,5449,5471,5477,5479,5483,5501,5503,5507,5519,5521,5527,5531,5557,5563,5569,5573,5581,5591,5623,5639,5641,5647,5651,5653,5657,5659,5669,5683,5689,5693,5701,5711,5717,5737,5741,5743,5749,5779,5783,5791,5801,5807,5813,5821,5827,5839,5843,5849,5851,5857,5861,5867,5869,5879,5881,5897,5903,5923,5927,5939,5953,5981,5987,6007,6011,6029,6037,6043,6047,6053,6067,6073,6079,6089,6091,6101,6113,6121,6131,6133,6143,6151,6163,6173,6197,6199,6203,6211,6217,6221,6229,6247,6257,6263,6269,6271,6277,6287,6299,6301,6311,6317,6323,6329,6337,6343,6353,6359,6361,6367,6373,6379,6389,6397,6421,6427,6449,6451,6469,6473,6481,6491,6521,6529,6547,6551,6553,6563,6569,6571,6577,6581,6599,6607,6619,6637,6653,6659,6661,6673,6679,6689,6691,6701,6703,6709,6719,6733,6737,6761,6763,6779,6781,6791,6793,6803,6823,6827,6829,6833,6841,6857,6863,6869,6871,6883,6899,6907,6911,6917,6947,6949,6959,6961,6967,6971,6977,6983,6991,6997,7001,7013,7019,7027,7039,7043,7057,7069,7079,7103,7109,7121,7127,7129,7151,7159,7177,7187,7193,7207,7211,7213,7219,7229,7237,7243,7247,7253,7283,7297,7307,7309,7321,7331,7333,7349,7351,7369,7393,7411,7417,7433,7451,7457,7459,7477,7481,7487,7489,7499,7507,7517,7523,7529,7537,7541,7547,7549,7559,7561,7573,7577,7583,7589,7591,7603,7607,7621,7639,7643,7649,7669,7673,7681,7687,7691,7699,7703,7717,7723,7727,7741,7753,7757,7759,7789,7793,7817,7823,7829,7841,7853,7867,7873,7877,7879,7883,7901,7907,7919,7927,7933,7937,7949,7951,7963,7993,8009,8011,8017,8039,8053,8059,8069,8081,8087,8089,8093,8101,8111,8117,8123,8147,8161,8167,8171,8179,8191,8209,8219,8221,8231,8233,8237,8243,8263,8269,8273,8287,8291,8293,8297,8311,8317,8329,8353,8363,8369,8377,8387,8389,8419,8423,8429,8431,8443,8447,8461,8467,8501,8513,8521,8527,8537,8539,8543,8563,8573,8581,8597,8599,8609,8623,8627,8629,8641,8647,8663,8669,8677,8681,8689,8693,8699,8707,8713,8719,8731,8737,8741,8747,8753,8761,8779,8783,8803,8807,8819,8821,8831,8837,8839,8849,8861,8863,8867,8887,8893,8923,8929,8933,8941,8951,8963,8969,8971,8999,9001,9007,9011,9013,9029,9041,9043,9049,9059,9067,9091,9103,9109,9127,9133,9137,9151,9157,9161,9173,9181,9187,9199,9203,9209,9221,9227,9239,9241,9257,9277,9281,9283,9293,9311,9319,9323,9337,9341,9343,9349,9371,9377,9391,9397,9403,9413,9419,9421,9431,9433,9437,9439,9461,9463,9467,9473,9479,9491,9497,9511,9521,9533,9539,9547,9551,9587,9601,9613,9619,9623,9629,9631,9643,9649,9661,9677,9679,9689,9697,9719,9721,9733,9739,9743,9749,9767,9769,9781,9787,9791,9803,9811,9817,9829,9833,9839,9851,9857,9859,9871,9883,9887,9901,9907,9923,9929,9931,9941,9949,9967,9973};
//“足量”的意思就是差不多就行了
int A[N1], l = 0, res = 0;
int F = 1;

signed main() {
	cin >> s >> e >> k;
	for(int I = s; I <= e; I++) {//挨个循环
		
		F = 0;
		for(int i = 0; i < 1000; i++) {//求得各个最小素数因子
			if(I%P[i] == 0) {
				A[l++] = P[i];
				F = 1;
				break;
			}
		}
		
		if(!F) {
			A[l++] = I;
		}
		
	}
	
    //排序+求和
	sort(A, A+l);
	for(int i = 0; i < k; i++) {
		res += A[i];
	}
	
	cout << res << "\n";
}

正解

显而易见，上述方法有用但愚蠢极致。正确的做法是：

一、容斥定理：能够证明1e6以内的素数能满足所以的最小素数因子能包含90%

二、欧拉筛：f(x)的值大于1e6的用欧拉筛来单独求解。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 5000010;
int f[N];
int prime[N],cnt;
bool vis[N];
bool dabiao[N];
void get_prime()//欧拉筛 
{
    for(int i=2;i<N;i++)
    {
        if(!vis[i]) prime[cnt++] = i,f[i]=i;
        for(int j=0;prime[j]*i<N;j++)
        {
            if(!f[prime[j]*i]) f[prime[j]*i]=prime[j];
            vis[i*prime[j]]=true;
            if(i%prime[j]==0) break;
        }
    }
}
void qujianshai(ll l,ll r){//区间筛 
    memset(f,0,sizeof f);
    for(ll i=0;i < cnt&&prime[i]*prime[i]<=r;i++){
        for(ll j=max( 2LL, (l+prime[i]-1)/prime[i]) * prime[i] ;j<=r;j+=prime[i]){
            if(j>=l){
                dabiao[j-l]=1;//1是合数 
                if(f[j-l]==0) f[j-l] = prime[i];
            }
        }
    }
}
ll st[N],t;
int main()
{
    get_prime();
    ll s,e,k;
    f[1]=1;
    cin>>s>>e>>k;
    qujianshai(s,e);
    for(ll i=0;i<=e-s;i++){
        if(dabiao[i]==0){ 
            st[++t]=i+s;
        }
        else{
            st[++t]=f[i];
        }
    }
    sort(st+1,st+t+1);
    ll ans=0;
    for(int i=1;i<=k;i++){
        ans+=st[i];
    }
    cout<<ans<<endl;
    return 0;
}

说实话，没太懂，但我找到一个更邪门的：

杂技流

源地址：(17条消息) 求最小素因子1e18_喝xiao果汁嘛的博客-CSDN博客

#include<bits/stdc++.h>
#define LL long long
using namespace std;
const int maxn=1e6+10;
LL a[maxn],idx;
int main(){
    LL s,e,k,ans=0;
    cin>>s>>e>>k;
    for(LL i=s;i<=e;i++){
        LL tmp=i;
        for(int j=2;j<=281;j++){
            if(tmp%j==0){//只要可以整除即可，当时没明白过来这一点。
                a[idx++]=j;
                break;
            }
        }
    }
    sort(a,a+idx);
    for(int i=0;i<k;i++){
        ans+=a[i];
    }
    cout<<ans<<endl;
    return 0;
}

7.5牛客排位

补题1：D Food Display Arrangement（贪心）

题意

给定一维数组，数字可能重复，每次操作可选定一个数字，将该数字的所有项放到首端或尾端，求最小操作数，使得所有同类型的数字之间没有其它数字（连续在一起）。

分析

哥们当时是真的分析不出来啊，一直以为是dp，后面看了题解才恍然大悟。

第一、将数字的所有项移到一边可以看成是删掉该数字。

第二、在此基础上我们只需要贪心地求解即可。贪心的依据就是当两个数字冲突了（即上一个数字还没到达它的最后出现的位置，遇到了另一个数字），这时就必定会删除一个；而越晚出现的数字，包含的数字就越多——到达最后出现的位置就越久——冲突的数字就会越多——删除的数字就会越多——操作越多——越不符合题意——所以，删除最晚出现的那个数字：

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

const int N = 1e5+10;
int n;
int A[N], res = 0;
map <int, int> last;
map <int, bool> vis;

//贪心思想，把数字往两边移动，相当于删去。 
signed main() {
	cin >> n;
	for(int i = 1; i <= n; i++) {
		cin >> A[i];
		last[A[i]] = i;//记录该数字的最后位置。 
	}
	
	int cur = A[1];//初始量设为第一个数 
	
	for(int i = 1; i <= n; i++) {
		if(A[i] == cur || vis[A[i]] == true) continue;//仍在跑当前这个数 or 遇到已经被删除的数 
		
		if(i < last[cur]) {//如果还没跑到这个数的结尾，和其它数冲突了，那么必然要删去一个数了 
			res++;//删！ 
			if(last[cur] > last[A[i]]) {//比较两个冲突的数谁的结束位置更后，删后的那个数（包含数字多的） 
				vis[cur] = true;//本数字的后，删本数字 
				cur = A[i];//新的数字 
			}
			else vis[A[i]] = true;//否则，删去另一个 
		}
		else cur = A[i];//上一个数已经跑完了，下一个数字。 
			
		
//		cout << i << " " << cur << " " << A[i] << " " << res << "\n"; 
	}
	
	cout << res << "\n";
}

感悟：这题，一眼字符串，二眼数论，三眼dp；傻*贪心——想你的时候没有，没发现你的时候哪里都是你。

补题2：E Making Connections（并查集）

题意

给出n个点和k次操作，操作1：将两个点连接起来；操作2：输出（各联通图点数^2 的和）/ 连通图数量。

分析

一眼并查集（好吧，是第二眼才看出来的）。但是当时太久没练了，差点就忘了怎么写了，还好之前打下的底子够硬，撑过来了。

这道题其实还算简单，操作1由并查集完成，操作2涉及到两个值sum（结点数平方和）和len（连通图数量），只需要在做并查集的时候更新这两个值就行。（额外更新这个数量级不允许，会超时）。

当两个连通图连接起来时：sum发生的变化 = 新连通图的结点数平方 - 两个旧连通图的节点数平方；连通图数量减一。

//七雄五霸斗春秋。顷刻兴亡过手。
#include <iostream>
using namespace std;
#define int long long

const int N = 1e5+10;
int n, m, h;
int a, b, sum, res;
int Sum[N], Vis[N];
int BTC[N];

void init() {//并查集第一步：自立为王
	for(int i = 1; i <= N; i++) {
		BTC[i] = i;
		Sum[i] = 1;
	}
}

int Find(int X) {//并查集第三步：老大的老大是我的老大
	if(X == BTC[X]) {//PS：原来我就是自己的老大，那没事了
		return X;
	}
	else {
		return BTC[X] = Find(BTC[X]);
	}
}

void Join(int a, int b) {//并查集第二步：站队分邦
	int A = Find(a);
	int B = Find(b);
	if(A != B) {
		
		res += (Sum[A]+Sum[B])*(Sum[A]+Sum[B]) - (Sum[A]*Sum[A]) - (Sum[B]*Sum[B]);//平方和的变化 = 新连通图的平方和 - 两个旧连通图的平方和
		Sum[A] += Sum[B];//把人数全加给新首领
		
		BTC[B] = A;//加入帮派
		sum--;//合并了就要减掉了。 
	}
} 

int min_num(int A, int B) {//找最大公因数

	while(A % B != 0) {
		int temp = B;
		B = A % B;
		A = temp;
	}
	
	return B;
}

signed main() {
	
	ios::sync_with_stdio(0);
	cout.tie(0); cin.tie(0);
	
	cin >> n >> m;
	
	res = n, sum = n; 
	
	init();
	
	while(m--) {
		
		cin >> h;
		
		if(h == 1) {
			cin >> a >> b;
			Join(a, b);
		}
		else {
			
			int V = min_num(res, sum);
			cout << res/V << "/" << sum/V << "\n"; //分式输出。
		}
	}
}

所以算法的知识点一定要搞清楚底层逻辑，进阶的难题一定会要你进行一些变化和调整的！

补题3：F Boxing Books（DP）

题意

给定n本书，k个箱子；书有宽w和高h两个属性，书有序，只能把连续的书放进一个箱子里，一个箱子的里的书消耗的成本 = 书宽和 * 最高的书高。求把n本书打包进k个箱子的最小成本。

分析

很熟悉的题，上面还有一个同类型的，只是转移的方程不太一样；书宽和可以用前缀和来存储，区间的书高可以二维数组来存储，这样就可以少一重循环，不会超时(╯▔皿▔)╯。

#include <iostream>
using namespace std;
#define int long long

const int N = 1e3+10;
int n, k, dp[N][N];//dp[i][j]表示i本书装进j个盒子的最小成本。 
struct Node {
	int w, h;
}A[N];//记录每本书

int maxh[N];//记录前i本书的最高高度，用于初始化的状态
int pre[N];//书宽度的前缀和，用于后面的状态转移
int H[N][N];//H[i][j]表示，第i本书到第j本书的最高高度，用于后面的状态转移

signed main() {
	cin >> n >> k;
	for(int i = 1; i <= n; i++) {
		cin >> A[i].w >> A[i].h;
		pre[i] = pre[i-1] + A[i].w;
		maxh[i] = max(maxh[i-1], A[i].h);
		H[i][i] = A[i].h;
 	}
	
    //存储区间书的最高度值
	for(int j = 1; j <= n; j++) {
		for(int i = j; i >= 1; i--) {
			H[i][j] = max(H[i][j], max(H[i+1][j], H[i][j-1]));
		}
	}
	
	//初始化数组，有两种情况需要初始化
	for(int i = 1; i <= n; i++) {
		for(int j = 1; j <= i; j++) {
			dp[i][j] = 1e18;
		}
		dp[i][1] = pre[i] * maxh[i];//i本书在一个箱子里
		dp[i][i] = dp[i-1][i-1] + A[i].w*A[i].h;//i本书在i个箱子里
	}
	
	for(int i = 2; i <= n; i++) {//不断添加书
		for(int j = 2; j < i; j++) {//不断添加箱子
			for(int l = j-1; l <= i-1; l++) {//l相当于一个辅助变量，没有实际意义。
//              这里如果不用前缀和和二维数组存储的话就需要多一层循环，时间复杂度变为1e12，会超时。
//				int maxxh = 0, sumw = 0;
//				for(int r = l+1; r <= i; r++) {
//					.....
//				}
                //求dp[i][j]，即dp[l][j-1]（l本书，j个箱子的最优解） + 从l+1到i本书的宽总和*从l+1到i本书的最高高度（成本）；
                //更新这个状态的状态包括：j-1本书，j-1个箱子 到 i-1本书，j-1个箱子的最小成本；
                //最小成本加上剩下的书宽和*剩下的书的最高高度，求出最小值就是此状态的最小成本。 
				dp[i][j] = min(dp[i][j], dp[l][j-1]+(pre[i]-pre[l])*H[l+1][i]);
				
				
			}
		}
	}
	
	cout << dp[n][k] << "\n";
}

补题4：G Bad Tree（二进制）

题意

给出两个整数，n 和 k ；n 代表 n 个有序不重复的整数（1~n）。k 代表 n 个整数在满足“条件”的字典序中的序号。“条件”：要求按照该顺序能构成一颗高度为 n-1 的搜索二叉树。

分析

本篇题解的压轴离谱题；

n个结点构成高度为 n-1 的搜索二叉树

== 每个结点只能有左子树或右子树

== 数列中任一一个数，其后面数要么都比它小，要么都比它大（不能同时出现两个数，一个数比它大，一个数比它小的数：：：因为如果是这种情况，那么该结点必定两个子树都有）

== 所以满足条件的序列从头开始填充，每次只能取当前最大的数 或 当前最小的数

== 因为最后一位即是最大又是最小，我们默认不管，且序号最小为1，我们从1开始，得到的就是：小小小 ..... 小 X。把“小”当作“0”，把“大”当作“1”。你就会惊奇的发现：

不理解，但大为震惊；我当时状态也是离谱了，能推到这一步，可是还算差一个特判！！

//为什么二进制是最好的进制？
#include <iostream>
using namespace std;
#define int long long

const int N = 110;
int n, k;
int min_num, max_num;
int temp[N], l, res[N];

signed main() {
	cin >> n >> k;
	min_num = 1, max_num = n;
	
	if(n == 1) {//“1”用特判，单纯是因为下面算法差不行
		if(k == 1) cout << "1\n";
		else cout << "-1\n"; 
		return 0;
	}
	
	//把序号通过转为二进制
	int r = 1;
	while(r < k) {
		r *= 2;
	}
	if(r != 1) r /= 2;

	k -= 1;

	while(r > 0) {
		if(k >= r) {
			k-=r;
			temp[l] = 1;
		}
		else {
			temp[l] = 0;
		}
		
		r /= 2;
		l++;
	}
    //至此得到；
	
	if(n < l+1) {//如果二进制的位数+1（最后一位）比n位要大，说明n位能表示的最大值不能到达，返回-1
		cout << "-1\n";
		return 0;
	}
	
//	for(int i = 0; i < l; i++) {
//		cout << temp[i];
//		if(i != l-1) cout << " ";
//		else cout << "\n";
//	}
	
	for(int i = n-1; i >= 1; i--) {//按位置填充到res的尾部
		res[i] = temp[--l];
		
		if(l <= 0) break; 
	}
	
//	for(int i = 1; i <= n; i++) {
//		cout << res[i];
//		if(i != n) cout << " ";
//		else cout << "\n";
//	}
	
	for(int i = 1; i <= n; i++) {//根据数组中的信息依次判断。
		if(res[i] == 0) cout << min_num++;
		else cout << max_num--;
		if(i != n) cout << " ";
		else cout << "\n";
	}
	
}

看了别人的代码，发现二进制那里可以优化：

vector<int> vc;

void get_bit(int X) {
    while(X) {
        int x = X % 2;
        vc.push_back(x);
        X /= 2;
    }
}

//注意，这种二进制是倒序的

至此，终于补完一份了...继续下一站吧

Rabbit_Ranger

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
ACM暑假补题 | 2023.7.4——2023.7.5

书有宽w和高h两个属性，书有序，只能把连续的书放进一个箱子里，一个箱子的里的书消耗的成本 = 书宽和 * 最高的书高。给定一维数组，数字可能重复，每次操作可选定一个数字，将该数字的所以重复项放到首端或尾端，求最小操作数，使得所有同类型的数字之间没有其它数字（连续在一起）。定义函数f(x)求得x的最小素数因子，在数字s到数字e的范围（包括s和e），累加从小到大排列的前k个因子，输出累加和。在二维平面的海里，有n个鱼的位置（给出x，y），用一张半径为r的网，求一次可以捕获到的鱼的最大数量。
复制链接

扫一扫