T1：lily
百合花（Lily）是一种美丽的花。她通常一年只开一次花，所以如果你看到百合花盛开，它会非常珍贵。然而，她对猫有剧毒，所以你必须注意让好奇的猫远离可爱的百合花。
你有n个网格的土壤土地排成一行，从1到n，其中一些是百合花。我们不想伤害百合，也不想伤害猫。你可以在网格上放一些猫粮，但对于任何有猫粮的网格i，在区域[i−1,i+1]不得含有百合花。你喜欢猫和百合，所以你想最大限度地增加有猫粮的格子。
设计满足上述要求的计划。
输入格式:
有一个整数n（1≤n≤1000）表示网格的数量。
第二行包含仅由“L”和“.”组成的字符串R，表示有和没有百合花的格子。
输出格式:
输出包含一行，字符串R′仅由“L”、“”组成和“C”，其中“C”表示在满足上述要求的同时分配给R中空网格的猫粮。
思路：在输入的时候将L这个点及对应的前后点分别标记为-1（考虑一下下标为0的点防止数组越界），然后在输出的时候，如果这个点是"."且没有被标记为-1，就输出C，其他点按照原样输出就行了
#include<bits/stdc++.h>
using namespace std;
string s;
int n,vis[100005];
int main()
{
cin>>n>>s;
for(int i=0;i<n;i++){
if(i==0&&s[i]=='L')vis[i]=-1;
else if(i==n-1&&s[i]=='L')vis[i-1]=-1,vis[i]=-1;
else if(s[i]=='L')vis[i-1]=-1,vis[i]=-1,vis[i+1]=-1;
}
for(int i=0;i<n;i++){
if(vis[i]!=-1&&s[i]=='.')cout<<'C';
else cout<<s[i];
}
return 0;
}T2：16进制下的高精度乘法
给出两个不超过1000位的十六进制数a,b。
求a∗b的值
输入格式:
输入共两行，两个十六进制的数
输出格式:
输出一行，表示a∗b
思路：三个主要的点
-
16进制转化为对应的10进制：即当这个char类型不为0到9，就char-'A'+10,
-
10进制转化为16进制：int+‘A'+10（但是好像也可以用cout<<hex<<x;
-
高精度乘法(记得去除前导零
#include<bits/stdc++.h>
using namespace std;
string x,y;
int a[100005],b[100005],c[100005];
int main()
{
cin>>x>>y;
int A=x.length(),B=y.length();
for(int i=0;i<A;i++){
if(x[i]>='0'&&x[i]<='9')a[A-i]=x[i]-'0';
else a[A-i]=x[i]-'A'+10;
}
for(int i=0;i<B;i++){
if(y[i]>='0'&&y[i]<='9')b[B-i]=y[i]-'0';
else b[B-i]=y[i]-'A'+10;
}
//cout<<a[1]<<' '<<b[1]<<endl;
for(int i=1;i<=A;i++){
for(int j=1;j<=B;j++){
c[i+j-1]+=(a[i]*b[j]);
c[i+j]+=c[i+j-1]/16;
c[i+j-1]%=16;
}
}
//cout<<c[3]<<c[2]<<c[1]<<endl;
int C=A+B;
while(c[C]==0&&C>1)C--;
for(int i=C;i>=1;i--)
{
if(c[i]>9)cout<<char(c[i]+'A'-10);
else cout<<c[i];
}
return 0;
}T2:山头狙击战
小明为了掩护大部队，单枪匹马同敌人周旋，后来被敌人包围在某山头……等等，为什么怎么听怎么像狼牙山五壮士！不过不用着急，这次小明携带了足够的弹药，完全可以将涌上来的敌人一个一个干掉。小明是个神枪手，只要他的枪膛中有子弹，他就能将在他射程m（用从敌人位置到山头的直线距离算）以内的一个敌人瞬间射杀。但如果在射程内没有敌人，出于节约子弹考虑和面子问题，小明会等待敌人靠近然后射击。
正当小明为自己的强大而自我膨胀时，他忽然发现了一个致命的失误：他携带的枪是单发枪，每射出一发子弹都必须花k秒钟的时间装子弹。而凶残的敌人才不会花时间等你换子弹呢。他们始终在以1m/s的速度接近山头。而如果在一个敌人到达山头时小明无法将他击毙，那么我们可怜的小明就将牺牲在敌人的刺刀下。现在小明用心灵感应向你发出求助：要保住自己的性命并且歼灭所有敌人，小明最多只能用多少时间给枪装上一发子弹？
说明：假设一开始小明的枪中就有一发子弹，并且一旦确定一个装弹时间，小明始终会用这个时间完成子弹的装卸。希望你能帮助小明脱离险境。
输入格式
每组输入数据，第一行有两个整数n和m，（2≤n≤100,000; 1≤m≤10,000,000）n代表敌人个数，m代表小明的射程。
接下来有n行，每行一个整数mi,（1≤mi≤10,000,000），代表每个敌人一开始相对山头的距离（单位为米）。
输出格式
每组输出数据仅有一个整数，代表小明的换弹时间（单位为秒）。
思路：二分法（主要是那个check函数
check函数：引入一个记录总时间的变量t，如果说第一个鬼子在射程之外，后续每射杀一个鬼子，这个时间t都要加上第一个鬼子与射程的差距，然后每次射杀一个鬼子，时间就加上换弹的时间x，对于其他超出射程的鬼子（不是第一个，这个时候t就会变成这个鬼子与射程的差距）
#include <bits/stdc++.h>
using namespace std;
int n,m,ans,t;
int mi[100005];
bool check(int x)
{
t=0;
if(mi[1]>m)t+=mi[1]-m;
for(int i=2;i<=n;i++){
t+=x;
if(t>mi[i])return 0;
if(mi[i]-t>m)t=mi[i]-m;
}
return 1;
}
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)cin>>mi[i];
sort(mi+1,mi+1+n);
int L=0,R=1e7,mid;
while(L<=R){
mid=(R+L)/2;
if(check(mid)){
L=mid+1;
}
else R=mid-1;
}
cout<<R;
return 0;
}T4：链表反转
Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K=3, then you must output 3→2→1→6→5→4; if K=4, you must output 4→3→2→1→5→6.
Input Specification:
Each input file contains one test case. For each case, the first line contains the address of the first node, a positive N (≤105) which is the total number of nodes, and a positive K (≤N) which is the length of the sublist to be reversed. The address of a node is a 5-digit nonnegative integer, and NULL is represented by -1.
Then N lines follow, each describes a node in the format:
Address Data Next
where Address is the position of the node, Data is an integer, and Next is the position of the next node.
Output Specification:
For each case, output the resulting ordered linked list. Each node occupies a line, and is printed in the same format as in the input.
思路：首先是读入地址（这个点特别坑，他可能给的是一个无效的地址），对应的节点序号，以及下一个地址，然后开始去除无效地址，以及对有效地址的计数，用另外一个set_a数组储存有效的地址，然后使用reverse函数实现反转，由于反转是按长度k反转的，那里要用i+=k，且能够反转的区间是1到s/k*k
在输出地址的时候记得补零（因为读入的时候是将将他作为一个int类型读入的)
#include<bits/stdc++.h>
using namespace std;
int main()
{
int first,n,L;
cin>>first>>n>>L;
int t,data[100005],next[100005],set_a[100005];
for(int i=1;i<=n;i++){
cin>>t;//输入地址，这个地址可能是无效的，比如下一个输入的地址可能会是-1 5 00000
cin>>data[t]>>next[t];//输入对应地址的节点及下一个地址
}
int s=0;//去除无效地址及对有效地址的记数
while(first!=-1)
{
s++;
set_a[s]=first;
first=next[first];//前往下一个地址
}
//使用reverse函数实现反转
for(int i=1;i<=s/L*L;i+=L)reverse(set_a+i,set_a+i+L);
for(int i=1;i<s;i++){
printf("%05d %d %05d\n",set_a[i],data[set_a[i]],set_a[i+1]);
}
printf("%05d %d -1",set_a[s],data[set_a[s]]);
return 0;
}T5；三元一次方程求解
给定一个形如ax3+bx2+cx+d=0的一元三次方程。
已知该方程有三个不同的实数根（根与根之差的绝对值≥10−6），且根范围均在[p,q]之间，你需要解出这个方程的三个根。
输入格式:
第一行一个整数T(1≤T≤1000)，表示有T组数据
接下来T行，每行6个实数，分别表示a,b,c,d,p,q
数据保证：−102≤p,q≤102，且对于∀x∈[p,q],−106≤f(x)≤106
输出格式:
输出三个实数，表示方程的三个解。
你的答案可以以任意顺序输出。
一个答案被认为是正确的，当且仅当其与标准答案的绝对误差不超过10−6
思路：暴力枚举加二分（开始我用求导+二分不知道为啥一直过不了，人debug都麻啦，反正很无语),
零点定理：若f（x）在闭区间【a,b】上连续，且f（a）*f（b）<0,则在开区间(a,b)内至少存在一点p，使得f（p）=0（求f（x）那里可以再优化一下，使用秦九韶公式）
#include <bits/stdc++.h>
using namespace std;
double a, b, c, d, p, q;
double F(double x) {
return a * x * x * x + b * x * x + c * x + d;
}
int cnt;
double eps=1e-6;
int main() {
int n; cin >> n;
while(n)
{
//cout<<"输入点"<<' ';
cin >> a >> b >> c >> d >> p >> q;
cout<<endl;
for (double i = p; i <= q+1; i +=0.1) {
double R = i + 0.1,L=i;
if (F(R) * F(L) < 0) {
while(R-L>=eps){
double mid=(R+L)/2;
if(F(R)*F(mid)<0)L=mid;
else R=mid;
}
cout << fixed << setprecision(6) << R << " ";
cnt++;
}
if (cnt == 3){cnt=0;break;}
}
n--;
}
return 0;
}
扫一扫
672
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
