目录
1 Lily
题目
百合花（Lily）是一种美丽的花。她通常一年只开一次花，所以如果你看到百合花盛开，它会非常珍贵。然而，她对猫有剧毒，所以你必须注意让好奇的猫远离可爱的百合花。
你有n个网格的土壤土地排成一行，从1到n，其中一些是百合花。我们不想伤害百合，也不想伤害猫。你可以在网格上放一些猫粮，但对于任何有猫粮的网格i，在区域[i−1,i+1]不得含有百合花。你喜欢猫和百合，所以你想最大限度地增加有猫粮的格子。
设计满足上述要求的计划。
输入格式:
有一个整数n（1≤n≤1000）表示网格的数量。
第二行包含仅由“L”和“.”组成的字符串R，表示有和没有百合花的格子。
输出格式:
输出包含一行，字符串R′仅由“L”、“”组成和“C”，其中“C”表示在满足上述要求的同时分配给R中空网格的猫粮。
输入样例:
在这里给出一组输入。例如：
5
..L..
输出样例:
在这里给出相应的输出。例如：
C.L.C题解
设置判断数组，将“L”及L旁边设为0，其余设为1。最后根据判断数组输出。
代码
#include<bits/stdc++.h>
using namespace std;
int a[1005];
int main(){
int n;
string str;
cin>>n>>str;
for(int i = 0;i<str.length();i++){
if(str[i] == 'L'){
a[i] = 1;
if(i == 0) a[i+1] =1;
else if(i == str.length()-1) a[i-1] =1;
else a[i+1] =1,a[i-1] =1;
}
}
for(int i = 0;i<str.length();i++){
if(a[i] == 1) cout<<str[i];
else cout<<"C";
}
return 0;
}
2. a * b
题目
给出两个不超过1000位的十六进制数a,b。
求a∗b的值
输入格式:
输入共两行，两个十六进制的数
输出格式:
输出一行，表示a∗b
输入样例:
在这里给出一组输入。例如：
1BF52
1D4B42
输出样例:
在这里给出相应的输出。例如：
332FCA5924题解
高精度乘法。只是以往的各位数可能变成两位数，并且最后的进位量程变成16，并且把9以上的数字变成ABCDEF，其余逻辑不变。
代码
#include<bits/stdc++.h>
using namespace std;
int a[1005],b[1005],c[2010];
void zhuan(string str,int a[]){
for(int i = 0;i<str.length(); i++){
if(str[i] >= '0' && str[i] <= '9') a[str.length()-i-1] = str[i] - '0';
else{
switch(str[i]){
case 'A':
a[str.length()-i-1] = 10;
break;
case 'B':
a[str.length()-i-1] = 11;
break;
case 'C':
a[str.length()-i-1] = 12;
break;
case 'D':
a[str.length()-i-1] = 13;
break;
case 'E':
a[str.length()-i-1] = 14;
break;
case 'F':
a[str.length()-i-1] = 15;
break;
default:break;
}
}
}
}
int main(){
string str1,str2;
cin>>str1>>str2;
zhuan(str1,a);
zhuan(str2,b);
//for(int i = 0;i<str1.length();i++) cout<<a[i]<<" ";
for(int i = 0;i<str1.length();i++){
for(int j = 0;j<str2.length();j++){
c[i+j] += a[i] * b[j];
//cout<<c[i+j]<<" ";
}
}
int cl = 2009;
for(int i = 0;i <= cl; i++){
if(c[i] > 15){
c[i+1] += c[i] / 16;
c[i] = c[i] %16;
}
}
while(c[cl] == 0) cl--;
for(int i = cl;i>=0;i--){
if(c[i]>=0 && c[i]<=9)cout<<c[i];
else{
switch(c[i]){
case 10:
cout<<"A";
break;
case 11:
cout<<"B";
break;
case 12:
cout<<"C";
break;
case 13:
cout<<"D";
break;
case 14:
cout<<"E";
break;
case 15:
cout<<"F";
break;
default:break;
}
}
}
return 0;
}
3.山头狙击战
题目
小明为了掩护大部队，单枪匹马同敌人周旋，后来被敌人包围在某山头……等等，为什么怎么听怎么像狼牙山五壮士！不过不用着急，这次小明携带了足够的弹药，完全可以将涌上来的敌人一个一个干掉。小明是个神枪手，只要他的枪膛中有子弹，他就能将在他射程m（用从敌人位置到山头的直线距离算）以内的一个敌人瞬间射杀。但如果在射程内没有敌人，出于节约子弹考虑和面子问题，小明会等待敌人靠近然后射击。
正当小明为自己的强大而自我膨胀时，他忽然发现了一个致命的失误：他携带的枪是单发枪，每射出一发子弹都必须花k秒钟的时间装子弹。而凶残的敌人才不会花时间等你换子弹呢。他们始终在以1m/s的速度接近山头。而如果在一个敌人到达山头时小明无法将他击毙，那么我们可怜的小明就将牺牲在敌人的刺刀下。现在小明用心灵感应向你发出求助：要保住自己的性命并且歼灭所有敌人，小明最多只能用多少时间给枪装上一发子弹？
说明：假设一开始小明的枪中就有一发子弹，并且一旦确定一个装弹时间，小明始终会用这个时间完成子弹的装卸。希望你能帮助小明脱离险境。
输入格式
每组输入数据，第一行有两个整数n和m，（2≤n≤100,000; 1≤m≤10,000,000）n代表敌人个数，m代表小明的射程。
接下来有n行，每行一个整数mi,（1≤mi≤10,000,000），代表每个敌人一开始相对山头的距离（单位为米）。
输出格式
每组输出数据仅有一个整数，代表小明的换弹时间（单位为秒）。
样例输入
6 100
236
120
120
120
120
120
样例输出
25题解
运用二分法，将换弹时间x作为目标，设置判断标准，若符合，则缩小，不符合则扩大范围，最后确定答案。
标准：先确定第一枪子弹的时间（离的最近的敌人在射程内则为0，不在射程内则要等到敌人进入射程为第一发子弹的时间）。将敌人按由近到远排序，第一个敌人可以走0*x米，第二个敌人可以走1*x米...若有敌人可以走的米数超过敌人和小明的距离，则这个换弹时间不行，若都没有超过，那么这个换弹时间可以。
代码
#include<bits/stdc++.h>
using namespace std;
int a[100005],n,m;
bool check(int x){
vector<int> c;
for(int i = 0;i<n;i++){
if(a[0] >= m) c.push_back(a[i] - a[0] + 100);
else c.push_back(a[i]);
}
sort(c.begin(),c.end());
int j = 0;
bool b = 1;
for(vector<int>::iterator it = c.begin(); it != c.end(); it++){
(*it) = (*it) - (j*x);
if((*it) < 0) {
b = 0;
break;
}
j++;
}
return b;
}
int main(){
cin>>n>>m;
for(int i = 0;i<n; i++){
cin>>a[i];
}
sort(a,a+n);
int l = 0,r = a[n-1];
while(l+1 < r){
int mid = (l+r) / 2;
if(check(mid)) l = mid;
else r = mid;
}
if(check(r)) cout<<r;
else cout<<l;
return 0;
}
4. Reversing Linked List
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.
Sample Input:
00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218
Sample Output:
00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1题解
创建一个链表，遇到需要改的地方，改变链表指向，最后按照结点指针一个一个输出。
思路搞明白了，但还是看的别人的才敲出来。
代码
#include<bits/stdc++.h>
using namespace std;
const int MAX1=1e+5;
struct node {
int Data,next;
};
int key, head;
struct node Node[MAX1];
int input(struct node Node[])
{
int Head, Length,address, data, next;
cin>>Head>>Length>>key;
for (int i = 0; i < Length; i++ ){
cin>>address>>data>>next;
Node[ address ].Data = data;
Node[ address ].next = next;
}
return Head;
}
int Count(int head, struct node Node[])
{
int i = head, count = 1;
while( Node[i].next != -1 ){
count++;
i = Node[i].next;
}
return count;
}
void print(int head, struct node Node[])
{
int putbefor = head;
while(Node[putbefor].next != -1)
{
printf( "%05d %d %05d\n", putbefor, Node[putbefor].Data, Node[putbefor].next );
putbefor = Node[putbefor].next;
}
printf( "%05d %d %d", putbefor, Node[putbefor].Data, Node[putbefor].next);
}
int change(struct node Node[],int *head,int k)
{
int count, p1, p2, p3,firstflag=0, nexthead=*head, lastend=-2;
if(k == 1) return 0;
count = Count(*head, Node);
while(count >= k){
p1 = nexthead;
p2 = Node[p1].next;
for(int i = 1; i < k; i++ ){
p3 = Node[p2].next;
Node[p2].next = p1;
p1 = p2;
p2 = p3;
}
Node[nexthead].next = p3;
if(firstflag == 0){
lastend = nexthead;
*head = p1;
}
else{
Node[lastend].next = p1;
lastend = nexthead;
}
firstflag++;
nexthead = p2;
count -= k;
}
}
int main()
{
head = input(Node);
change(Node, &head, key);
print(head, Node);
}
5.一元三次方程
给定一个形如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
输入样例:
在这里给出一组输入。例如：
1
1.000000 -5.000000 -4.000000 20.000000 -10.000000 10.000000
输出样例:
在这里给出相应的输出。例如：
-2.000000 2.000000 5.000000题解
运用二分法的思想。一元三次函数可以确定三个点的范围，在范围内用二分法来做一一锁定，最后输出答案。
代码
#include<bits/stdc++.h>
using namespace std;
double a,b,c,d,p,q;
double fun(double x){
return a*x*x*x + b*x*x + c*x + d;
}
double f(double x1, double x2){
double mid;
while(1)
{
mid = (x1 + x2) / 2;
if( fabs(x1 - x2 ) < 1E-8) return mid;
else
{
if(fun(mid) == 0) return mid;
else if(fun(x1)*fun(mid ) < 0) x2 = mid;
else x1 = mid;
}
}
}
int main(){
int t;
cin>>t;
for(int i = 0;i<t;i++){
cin>>a>>b>>c>>d>>p>>q;
double x1, x2;
x1 = (-2 * b - sqrt(4 * b * b - 12 * a * c)) / (6 * a);
x2 = (-2 * b + sqrt(4 * b * b - 12 * a * c)) / (6 * a);
printf("%.7lf %.7lf %.7lf\n", f(-100, x1), f(x1, x2), f(x2, 100));
}
return 0;
}
扫一扫
386
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
