AtCoder Beginnner Contest 070

vi还没配置（旧电脑，不想再折腾啦），空格缩进不合格，，请见谅

A（三位数，取第一位和最后一位）

#include <bits/stdc++.h>
using namespace std;
int main(){
        int n;
        scanf("%d",&n);
        int x=n/100;
        int y=n%10;
        if(x==y) printf("Yes
");
        else printf("No
");
        return 0;
}

B  (可以联想成求两个集合的交集)

#include <bits/stdc++.h>
using namespace std;
int main(){
        int a,b,m,n;
        scanf("%d%d%d%d",&a,&b,&m,&n);
        if(b<=m){
        return !printf("0
");
        }else{
        if(a<m){
        if(b<=n){
        printf("%d
",b-m);
                        }else {
        printf("%d
",n-m);
                        }
                }else {
                if(n>a){
                if(n<=b) return !printf("%d
",n-a);
                else return!printf("%d
",b-a);
                        } else return !printf("0
");

                }
        }
}

C(求最大公倍数-->两个数相乘除以两个数的最大公约数就是最小公倍数，给n个数求n个数的最小公倍数，只能遍历啦 )

#include <bits/stdc++.h>
using namespace std;
#define ll long long int
ll gcd(ll  a,ll b){
        return b?gcd(b,a%b):a;
}

ll  a[110];
int main(){
        int n;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        cin>>a[i];
        ll ans=a[0];
        for(int i=1;i<n;i++){
         ans=ans/gcd(ans,a[i])*a[i];
        }
        return !printf("%lld
",ans);
}

D - Transit Tree Path

---

Time limit : 2sec / Memory limit : 256MB

Score : 400 points

Problem Statement

You are given a tree with N vertices.
Here, a tree is a kind of graph, and more specifically, a connected undirected graph with N−1 edges, where N is the number of its vertices.
The i-th edge (1≤i≤N−1) connects Vertices a_i and b_i, and has a length of c_i.

You are also given Q queries and an integer K. In the j-th query (1≤j≤Q):

• find the length of the shortest path from Vertex x_j and Vertex y_j via Vertex K.

Constraints

• 3≤N≤10⁵
• 1≤a_i,b_i≤N(1≤i≤N−1)
• 1≤c_i≤10⁹(1≤i≤N−1)
• The given graph is a tree.
• 1≤Q≤10⁵
• 1≤K≤N
• 1≤x_j,y_j≤N(1≤j≤Q)
• x_j≠y_j(1≤j≤Q)
• x_j≠K,y_j≠K(1≤j≤Q)

---

Input

Input is given from Standard Input in the following format:

N  
a1 b1 c1  
:  
aN−1 bN−1 cN−1
Q K
x1 y1
:  
xQ yQ

Output

Print the responses to the queries in Q lines.
In the j-th line j(1≤j≤Q), print the response to the j-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 1: Vertex 2 → Vertex 1 → Vertex 2 → Vertex 4 : Length 1+1+1=3
• Query 2: Vertex 2 → Vertex 1 → Vertex 3 : Length 1+1=2
• Query 3: Vertex 4 → Vertex 2 → Vertex 1 → Vertex 3 → Vertex 5 : Length 1+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=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

题意：给定一个N，代表有N个节点，构成一个具有N-1条边的无向图，节点之间的边带权值，因为

• x_j≠y_j(1≤j≤Q)_{这个条件，没有圈，所以严格上说是一颗树}

• Q次查询，每次查询必须经过K，问每次查询_{的最短路径是多少}

    #include <stdio.h>
    #include <string.h>
    #include <queue>
    #include <vector>
    using namespace std;
     
    struct edge
    {
        int from,to;
        int cost;
    };
     
    long long d[100005];
    bool vis[100005];
     
    vector<edge> edges;
    vector<int> v[100005];
     
    void adde(int from,int to,int cost)
    {
        edge e;
        e.from = from;
        e.to = to;
        e.cost = cost;
     
        edges.push_back(e);
     
        int m = edges.size() - 1;
     
        v[from].push_back(m);
    }
     
    void bfs(int s)
    {
        vis[s] = 1;
        d[s] = 0;
     
        queue<int> q;
     
        q.push(s);
     
        while (!q.empty())
        {
            int now = q.front();q.pop();
     
            for (int i = 0;i < v[now].size();i++)
            {
                int id = v[now][i];
     
                edge tmp = edges[id];
     
                if (!vis[tmp.to])
                {
                    vis[tmp.to] = 1;
     
                    d[tmp.to] = d[now] + tmp.cost;
     
                    q.push(tmp.to);
                }
            }
        }
    }
     
    int main()
    {
        int n;
     
        scanf("%d",&n);
     
        for (int i = 1;i <= n - 1;i++)
        {
            int a,b,c;
     
            scanf("%d%d%d",&a,&b,&c);
     
            adde(a,b,c);
            adde(b,a,c);
        }
     
        int q,k;
     
        scanf("%d%d",&q,&k);
     
        bfs(k);
     
        for (int i = 0;i < q;i++)
        {
            int a,b;
     
            scanf("%d%d",&a,&b);
     
            printf("%lld
",d[a] + d[b]);
        }
     
        return 0;
    }