我好想有点思维江化,所以我想给这个丝毫没有问题的abc也写下
A - Palindromic Number
Time Limit: 2 sec / Memory Limit: 256 MB
Score : 100100 points
Problem Statement
You are given a three-digit positive integer NN.
Determine whether NN is a palindromic number.
Here, a palindromic number is an integer that reads the same backward as forward in decimal notation.
Constraints
- 100≤N≤999100≤N≤999
- NN is an integer.
Input
Input is given from Standard Input in the following format:
NN
Output
If NN is a palindromic number, print Yes
; otherwise, print No
.
Sample Input 1 Copy
575
Sample Output 1 Copy
Yes
N=575N=575 is also 575575 when read backward, so it is a palindromic number. You should print Yes
.
Sample Input 2 Copy
123
Sample Output 2 Copy
No
N=123N=123 becomes 321321 when read backward, so it is not a palindromic number. You should print No
.
Sample Input 3 Copy
812
Sample Output 3 Copy
No
Palindromic这个词必须熟啊,回文串的,直接搞,就是这点我感觉自己思想僵化,就是上次让判断时间是不是回文串一样的
我神特么写了个判断倒过来的数是不是一样的,石乐志,就是按照字符串读也比这个好啊
#include <bits/stdc++.h> using namespace std; int la(int n){ int s=0; while(n){ int t=n%10; s=s*10+t; n/=10; } return s; } int main() { int n; cin>>n; printf("%s\n",n==la(n)?"Yes":"No"); return 0; }
其实只是判断百位和个位是否相同就好了
#include <stdio.h> #include <bits/stdc++.h> using namespace std; int main() { int n; cin>>n; printf("%s\n",n/100==n%10?"Yes":"No"); return 0; }
B - Two Switches
Time Limit: 2 sec / Memory Limit: 256 MB
Score : 200200 points
Problem Statement
Alice and Bob are controlling a robot. They each have one switch that controls the robot.
Alice started holding down her button AA second after the start-up of the robot, and released her button BB second after the start-up.
Bob started holding down his button CC second after the start-up, and released his button DD second after the start-up.
For how many seconds both Alice and Bob were holding down their buttons?
Constraints
- 0≤A<B≤1000≤A<B≤100
- 0≤C<D≤1000≤C<D≤100
- All input values are integers.
Input
Input is given from Standard Input in the following format:
AA BB CC DD
Output
Print the length of the duration (in seconds) in which both Alice and Bob were holding down their buttons.
Sample Input 1 Copy
0 75 25 100
Sample Output 1 Copy
50
Alice started holding down her button 00 second after the start-up of the robot, and released her button 7575 second after the start-up.
Bob started holding down his button 2525 second after the start-up, and released his button 100100 second after the start-up.
Therefore, the time when both of them were holding down their buttons, is the 5050 seconds from 2525 seconds after the start-up to 7575 seconds after the start-up.
Sample Input 2 Copy
0 33 66 99
Sample Output 2 Copy
0
Alice and Bob were not holding their buttons at the same time, so the answer is zero seconds.
Sample Input 3 Copy
10 90 20 80
Sample Output 3 Copy
60
线段重合部分,直接水过
#include <bits/stdc++.h> using namespace std; int main() { int a,b,c,d,f; cin>>a>>b>>c>>d; f=min(d,b)-max(a,c); if(f<0)f=0; cout<<f<<endl; return 0; }
C - Multiple Clocks
Time Limit: 2 sec / Memory Limit: 256 MB
Score : 300300 points
Problem Statement
We have NN clocks. The hand of the ii-th clock (1≤i≤N)(1≤i≤N) rotates through 360°360° in exactly TiTi seconds.
Initially, the hand of every clock stands still, pointing directly upward.
Now, Dolphin starts all the clocks simultaneously.
In how many seconds will the hand of every clock point directly upward again?
Constraints
- 1≤N≤1001≤N≤100
- 1≤Ti≤10181≤Ti≤1018
- All input values are integers.
- The correct answer is at most 10181018 seconds.
Input
Input is given from Standard Input in the following format:
NN T1T1 :: TNTN
Output
Print the number of seconds after which the hand of every clock point directly upward again.
Sample Input 1 Copy
2 2 3
Sample Output 1 Copy
6
We have two clocks. The time when the hand of each clock points upward is as follows:
- Clock 11: 22, 44, 66, ...... seconds after the beginning
- Clock 22: 33, 66, 99, ...... seconds after the beginning
Therefore, it takes 66 seconds until the hands of both clocks point directly upward.
Sample Input 2 Copy
5 2 5 10 1000000000000000000 1000000000000000000
Sample Output 2 Copy
1000000000000000000
最小公倍数,代码不能再短了
#include <bits/stdc++.h> using namespace std; typedef long long LL; int main() { int n; cin>>n; LL s=1; for(int i=0;i<n;i++){ LL x; cin>>x; s=x/__gcd(x,s)*s; } cout<<s<<endl; return 0; }
Time Limit: 2 sec / Memory Limit: 256 MB
Score : 400400 points
Problem Statement
You are given a tree with NN vertices.
Here, a tree is a kind of graph, and more specifically, a connected undirected graph with N−1N−1 edges, where NN is the number of its vertices.
The ii-th edge (1≤i≤N−1)(1≤i≤N−1) connects Vertices aiai and bibi, and has a length of cici.
You are also given QQ queries and an integer KK. In the jj-th query (1≤j≤Q)(1≤j≤Q):
- find the length of the shortest path from Vertex xjxj and Vertex yjyj via Vertex KK.
Constraints
- 3≤N≤1053≤N≤105
- 1≤ai,bi≤N(1≤i≤N−1)1≤ai,bi≤N(1≤i≤N−1)
- 1≤ci≤109(1≤i≤N−1)1≤ci≤109(1≤i≤N−1)
- The given graph is a tree.
- 1≤Q≤1051≤Q≤105
- 1≤K≤N1≤K≤N
- 1≤xj,yj≤N(1≤j≤Q)1≤xj,yj≤N(1≤j≤Q)
- xj≠yj(1≤j≤Q)xj≠yj(1≤j≤Q)
- xj≠K,yj≠K(1≤j≤Q)xj≠K,yj≠K(1≤j≤Q)
Input
Input is given from Standard Input in the following format:
NN a1a1 b1b1 c1c1 :: aN−1aN−1 bN−1bN−1 cN−1cN−1 QQ KK x1x1 y1y1 :: xQxQ yQyQ
Output
Print the responses to the queries in QQ lines.
In the jj-th line j(1≤j≤Q)j(1≤j≤Q), print the response to the jj-th query.
Sample Input 1 Copy
5 1 2 1 1 3 1 2 4 1 3 5 1 3 1 2 4 2 3 4 5
Sample Output 1 Copy
3 2 4
The shortest paths for the three queries are as follows:
- Query 11: Vertex 22 → Vertex 11 → Vertex 22 → Vertex 44 : Length 1+1+1=31+1+1=3
- Query 22: Vertex 22 → Vertex 11 → Vertex 33 : Length 1+1=21+1=2
- Query 33: Vertex 44 → Vertex 22 → Vertex 11 → Vertex 33 → Vertex 55 : Length 1+1+1+1=41+1+1+1=4
Sample Input 2 Copy
7 1 2 1 1 3 3 1 4 5 1 5 7 1 6 9 1 7 11 3 2 1 3 4 5 6 7
Sample Output 2 Copy
5 14 22
The path for each query must pass Vertex K=2K=2.
Sample Input 3 Copy
10 1 2 1000000000 2 3 1000000000 3 4 1000000000 4 5 1000000000 5 6 1000000000 6 7 1000000000 7 8 1000000000 8 9 1000000000 9 10 1000000000 1 1 9 10
Sample Output 3 Copy
17000000000
这个题哪有那么多幺蛾子,直接递归上去就好了
#include <bits/stdc++.h> using namespace std; const int N=100005; typedef long long ll; struct to{ ll l,t; }; vector<to> mp[N]; ll dis[N]; void dfs(ll u,ll fa){ for(ll i=0; i<mp[u].size(); i++){ ll v=mp[u][i].t; if(v==fa) continue; dis[v]=dis[u]+mp[u][i].l; dfs(v,u); } return; } int main(){ ll n,a,b,c,q,k,x,y; cin>>n; for(ll i=1; i<n; i++){ cin>>a>>b>>c; mp[a].push_back((to){c,b}); mp[b].push_back((to){c,a}); } cin>>q>>k; dfs(k,0); for(ll i=0; i<q; i++){ cin>>x>>y; cout<<dis[x]+dis[y]<<endl; } return 0; }