AtCoder Beginner Contest 070

我好想有点思维江化，所以我想给这个丝毫没有问题的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 $\mathrm{NN}$.
Determine whether $\mathrm{NN}$ is a palindromic number.
Here, a palindromic number is an integer that reads the same backward as forward in decimal notation.

Constraints

• $\mathrm{100\le N\le 999100\le N\le 999}$
• $\mathrm{NN}$ is an integer.

---

Input

Input is given from Standard Input in the following format:

$\mathrm{NN}$

Output

If $\mathrm{NN}$ is a palindromic number, print Yes; otherwise, print No.

---

Sample Input 1 Copy

Copy

575

Sample Output 1 Copy

Copy

Yes

$\mathrm{N=575N=575}$ is also $575575$ when read backward, so it is a palindromic number. You should print Yes.

---

Sample Input 2 Copy

Copy

123

Sample Output 2 Copy

Copy

No

$\mathrm{N=123N=123}$ becomes $321321$ when read backward, so it is not a palindromic number. You should print No.

---

Sample Input 3 Copy

Copy

812

Sample Output 3 Copy

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==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/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 $\mathrm{AA}$ second after the start-up of the robot, and released her button $\mathrm{BB}$ second after the start-up.
Bob started holding down his button $\mathrm{CC}$ second after the start-up, and released his button $\mathrm{DD}$ second after the start-up.
For how many seconds both Alice and Bob were holding down their buttons?

Constraints

• $\mathrm{0\le A<B\le 1000\le A<B\le 100}$
• $\mathrm{0\le C<D\le 1000\le C<D\le 100}$
• All input values are integers.

---

Input

Input is given from Standard Input in the following format:

$\mathrm{AA}$ $\mathrm{BB}$ $\mathrm{CC}$ $\mathrm{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

Copy

0 75 25 100

Sample Output 1 Copy

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

Copy

0 33 66 99

Sample Output 2 Copy

Copy

0

Alice and Bob were not holding their buttons at the same time, so the answer is zero seconds.

---

Sample Input 3 Copy

Copy

10 90 20 80

Sample Output 3 Copy

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 $\mathrm{NN}$ clocks. The hand of the $\mathrm{ii}$-th clock $(1\le i\le N)(1\le i\le N)$ rotates through $\mathrm{360°360°}$ in exactly ${\mathrm{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

• $\mathrm{1\le N\le 1001\le N\le 100}$
• $\mathrm{1\le Ti\le 10181\le Ti\le 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:

$\mathrm{NN}$
${\mathrm{T1T1}}^{}$
$::$  
${\mathrm{TNTN}}^{}$

Output

Print the number of seconds after which the hand of every clock point directly upward again.

---

Sample Input 1 Copy

Copy

2
2
3

Sample Output 1 Copy

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

Copy

5
2
5
10
1000000000000000000
1000000000000000000

Sample Output 2 Copy

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;
}

D - Transit Tree Path

---

Time Limit: 2 sec / Memory Limit: 256 MB

Score : $400400$ points

Problem Statement

You are given a tree with $\mathrm{NN}$ vertices.
Here, a tree is a kind of graph, and more specifically, a connected undirected graph with $\mathrm{N-1N-1}$ edges, where $\mathrm{NN}$ is the number of its vertices.
The $\mathrm{ii}$-th edge $(1\le i\le N-1)(1\le i\le N-1)$ connects Vertices ${\mathrm{aiai}}^{}$ and ${\mathrm{bibi}}^{}$, and has a length of ${\mathrm{cici}}^{}$.

You are also given $\mathrm{QQ}$ queries and an integer $\mathrm{KK}$. In the $\mathrm{jj}$-th query $(1\le j\le Q)(1\le j\le Q)$:

• find the length of the shortest path from Vertex ${\mathrm{xjxj}}^{}$ and Vertex ${\mathrm{yjyj}}^{}$ via Vertex $\mathrm{KK}$.

Constraints

• $\mathrm{3\le N\le 1053\le N\le 105}$
• $\mathrm{1\le ai,bi\le N(1\le i\le N-1)1\le ai,bi\le N(1\le i\le N-1)}$
• $\mathrm{1\le ci\le 109(1\le i\le N-1)1\le ci\le 109(1\le i\le N-1)}$
• The given graph is a tree.
• $\mathrm{1\le Q\le 1051\le Q\le 105}$
• $\mathrm{1\le K\le N1\le K\le N}$
• $\mathrm{1\le xj,yj\le N(1\le j\le Q)1\le xj,yj\le N(1\le j\le Q)}$
• ${\mathrm{xj\ne yj(1\le j\le Q)xj\ne yj(1\le j\le Q)}}^{}$
• ${\mathrm{xj\ne K,yj\ne K(1\le j\le Q)xj\ne K,yj\ne K(1\le j\le Q)}}^{}$

---

Input

Input is given from Standard Input in the following format:

$\mathrm{NN}$  
${\mathrm{a1a1}}^{}$ ${\mathrm{b1b1}}^{}$ ${\mathrm{c1c1}}^{}$  
$::$  
${\mathrm{aN-1aN-1}}^{}$ ${\mathrm{bN-1bN-1}}^{}$ ${\mathrm{cN-1cN-1}}^{}$
$\mathrm{QQ}$ $\mathrm{KK}$
${\mathrm{x1x1}}^{}$ ${\mathrm{y1y1}}^{}$
$::$  
${\mathrm{xQxQ}}^{}$ ${\mathrm{yQyQ}}^{}$

Output

Print the responses to the queries in $\mathrm{QQ}$ lines.
In the $\mathrm{jj}$-th line $\mathrm{j(1\le j\le Q)j(1\le j\le Q)}$, print the response to the $\mathrm{jj}$-th query.

---

Sample Input 1 Copy

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

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 $\mathrm{1+1+1=31+1+1=3}$
• Query $22$: Vertex $22$ → Vertex $11$ → Vertex $33$ : Length $\mathrm{1+1=21+1=2}$
• Query $33$: Vertex $44$ → Vertex $22$ → Vertex $11$ → Vertex $33$ → Vertex $55$ : Length $\mathrm{1+1+1+1=41+1+1+1=4}$

---

Sample Input 2 Copy

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

Copy

5
14
22

The path for each query must pass Vertex $\mathrm{K=2K=2}$.

---

Sample Input 3 Copy

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

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;
}