PAT – liuchuo

PAT 1148 Werewolf – Simple Version – 甲级

Werewolf（狼人杀） is a game in which the players are partitioned into two parties: the werewolves and the human beings. Suppose that in a game,

player #1 said: “Player #2 is a werewolf.”;
player #2 said: “Player #3 is a human.”;
player #3 said: “Player #4 is a werewolf.”;
player #4 said: “Player #5 is a human.”; and
player #5 said: “Player #4 is a human.”.
Given that there were 2 werewolves among them, at least one but not all the werewolves were lying, and there were exactly 2 liers. Can you point out the werewolves?

Now you are asked to solve a harder version of this problem: given that there were N players, with 2 werewolves among them, at least one but not all the werewolves were lying, and there were exactly 2 liers. You are supposed to point out the werewolves.

Input Specification:
Each input file contains one test case. For each case, the first line gives a positive integer N (5≤N≤100). Then N lines follow and the i-th line gives the statement of the i-th player (1≤i≤N), which is represented by the index of the player with a positive sign for a human and a negative sign for a werewolf.

Output Specification:
If a solution exists, print in a line in ascending order the indices of the two werewolves. The numbers must be separated by exactly one space with no extra spaces at the beginning or the end of the line. If there are more than one solution, you must output the smallest solution sequence — that is, for two sequences A=a[1],…,a[M] and B=b[1],…,b[M], if there exists 0≤k[k+1]<b[k+1], then A is said to be smaller than B. In case there is no solution, simply print No Solution.

Sample Input 1:
5
-2
+3
-4
+5
+4
Sample Output 1:
1 4
Sample Input 2:
6
+6
+3
+1
-5
-2
+4
Sample Output 2 (the solution is not unique):
1 5
Sample Input 3:
5
-2
-3
-4
-5
-1
Sample Output 3:
No Solution

题目大意：已知 N 名玩家中有 2 人扮演狼人角色，有 2 人说的不是实话，有狼人撒谎但并不是所有狼人都在撒谎。要求你找出扮演狼人角色的是哪几号玩家，如果有解，在一行中按递增顺序输出 2 个狼人的编号；如果解不唯一，则输出最小序列解；若无解则输出 No Solution～

分析：每个人说的数字保存在v数组中，i从1～n、j从i+1～n遍历，分别假设i和j是狼人，a数组表示该人是狼人还是好人，等于1表示是好人，等于-1表示是狼人。k从1～n分别判断k所说的话是真是假，k说的话和真实情况不同（即v[k] * a[abs(v[k])] < 0）则表示k在说谎，则将k放在lie数组中；遍历完成后判断lie数组，如果说谎人数等于2并且这两个说谎的人一个是好人一个是狼人（即a[lie[0]] + a[lie[1]] == 0）表示满足题意，此时输出i和j并return，否则最后的时候输出No Solution～

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
int main() {
    int n;
    cin >> n;
    vector<int> v(n+1);
    for (int i = 1; i <= n; i++) cin >> v[i];
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            vector<int> lie, a(n + 1, 1);
            a[i] = a[j] = -1;
            for (int k = 1; k <= n; k++)
                if (v[k] * a[abs(v[k])] < 0) lie.push_back(k);
            if (lie.size() == 2 && a[lie[0]] + a[lie[1]] == 0) {
                cout << i << " " << j;
                return 0;
            }
        }
    }
    cout << "No Solution";
    return 0;
}

#include <iostream>

#include <vector>

#include <cmath>

using namespace std;

int main() {

int n;

cin >> n;

vector<int> v(n+1);

for (int i = 1; i <= n; i++) cin >> v[i];

for (int i = 1; i <= n; i++) {

for (int j = i + 1; j <= n; j++) {

vector<int> lie, a(n + 1, 1);

a[i] = a[j] = -1;

for (int k = 1; k <= n; k++)

if (v[k] * a[abs(v[k])] < 0) lie.push_back(k);

if (lie.size() == 2 && a[lie[0]] + a[lie[1]] == 0) {

cout << i << " " << j;

return 0;

}

cout << "No Solution";

return 0;

}

1087 有多少不同的值（20 分）-PAT乙级真题

当自然数 n 依次取 1、2、3、……、N 时，算式 ⌊n/2⌋+⌊n/3⌋+⌊n/5⌋ 有多少个不同的值？（注：⌊x⌋ 为取整函数，表示不超过 x 的最大自然数，即 x 的整数部分。）

输入格式：
输入给出一个正整数 N（2≤N≤10⁴）。

输出格式：
在一行中输出题面中算式取到的不同值的个数。

输入样例：
2017
输出样例：
1480

分析：把i/2 + i/3 + i/n的值插入到set中，输出set的size就是算式中不同值的个数～

#include <iostream>
#include <set>
using namespace std;
int main() {
    int n;
    scanf("%d", &n);
    set<int> s;
    for (int i = 1; i <= n; i++)
        s.insert(i / 2 + i / 3 + i / 5);
    printf("%d", s.size());
    return 0;
}

#include <iostream>

#include <set>

using namespace std;

int main() {

int n;

scanf("%d", &n);

set<int> s;

for (int i = 1; i <= n; i++)

s.insert(i / 2 + i / 3 + i / 5);

printf("%d", s.size());

return 0;

}

1090 危险品装箱（25 分）-PAT乙级真题

集装箱运输货物时，我们必须特别小心，不能把不相容的货物装在一只箱子里。比如氧化剂绝对不能跟易燃液体同箱，否则很容易造成爆炸。

本题给定一张不相容物品的清单，需要你检查每一张集装箱货品清单，判断它们是否能装在同一只箱子里。

输入格式：
输入第一行给出两个正整数：N (≤10^4) 是成对的不相容物品的对数；M (≤100) 是集装箱货品清单的单数。

随后数据分两大块给出。第一块有 N 行，每行给出一对不相容的物品。第二块有 M 行，每行给出一箱货物的清单，格式如下：

K G[1] G[2] … G[K]
其中 K (≤1000) 是物品件数，G[i] 是物品的编号。简单起见，每件物品用一个 5 位数的编号代表。两个数字之间用空格分隔。

输出格式：
对每箱货物清单，判断是否可以安全运输。如果没有不相容物品，则在一行中输出 Yes，否则输出 No。

输入样例：
6 3
20001 20002
20003 20004
20005 20006
20003 20001
20005 20004
20004 20006
4 00001 20004 00002 20003
5 98823 20002 20003 20006 10010
3 12345 67890 23333
输出样例：
No
Yes
Yes

分析：用map存储每一个货物的所有不兼容货物～在判断给出的一堆货物是否是相容的时候，判断任一货物的不兼容货物是否在这堆货物中～如果存在不兼容的货物，则这堆货物不能相容～如果遍历完所有的货物，都找不到不兼容的两个货物，则这堆货物就是兼容的～

#include <iostream>
#include <vector>
#include <map>
using namespace std;
int main() {
    int n, k, t1, t2;
    map<int,vector<int>> m;
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++) {
        scanf("%d%d", &t1, &t2);
        m[t1].push_back(t2);
        m[t2].push_back(t1);
    }
    while (k--) {
        int cnt, flag = 0, a[100000] = {0};
        scanf("%d", &cnt);
        vector<int> v(cnt);
        for (int i = 0; i < cnt; i++) {
            scanf("%d", &v[i]);
            a[v[i]] = 1;
        }
        for (int i = 0; i < v.size(); i++)
            for (int j = 0; j < m[v[i]].size(); j++)
                if (a[m[v[i]][j]] == 1) flag = 1;
        printf("%s\n",flag ? "No" :"Yes");
    }
    return 0;
}

#include <iostream>

#include <vector>

#include <map>

using namespace std;

int main() {

int n, k, t1, t2;

map<int,vector<int>> m;

scanf("%d%d", &n, &k);

for (int i = 0; i < n; i++) {

scanf("%d%d", &t1, &t2);

m[t1].push_back(t2);

m[t2].push_back(t1);

}

while (k--) {

int cnt, flag = 0, a[100000] = {0};

scanf("%d", &cnt);

vector<int> v(cnt);

for (int i = 0; i < cnt; i++) {

scanf("%d", &v[i]);

a[v[i]] = 1;

}

for (int i = 0; i < v.size(); i++)

for (int j = 0; j < m[v[i]].size(); j++)

if (a[m[v[i]][j]] == 1) flag = 1;

printf("%s\n",flag ? "No" :"Yes");

}

return 0;

}

[Java] 1030. Travel Plan (30)-PAT甲级

1030. Travel Plan (30)
A traveler’s map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path between his/her starting city and the destination. If such a shortest path is not unique, you are supposed to output the one with the minimum cost, which is guaranteed to be unique.

Input Specification:

Each input file contains one test case. Each case starts with a line containing 4 positive integers N, M, S, and D, where N (<=500) is the number of cities (and hence the cities are numbered from 0 to N-1); M is the number of highways; S and D are the starting and the destination cities, respectively. Then M lines follow, each provides the information of a highway, in the format:

City1 City2 Distance Cost

where the numbers are all integers no more than 500, and are separated by a space.

Output Specification:

For each test case, print in one line the cities along the shortest path from the starting point to the destination, followed by the total distance and the total cost of the path. The numbers must be separated by a space and there must be no extra space at the end of output.

Sample Input
4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20
Sample Output
0 2 3 3 40
题目大意：求起点到终点的最短路径最短距离和花费，要求首先路径最短，其次花费最少，要输出完整路径

PS：感谢github用户@fs19910227提供的pull request～

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.PriorityQueue;

public class Main {
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

    static class Info {
        int distance, cost;

        Info(int distance, int cost) {
            this.distance = distance;
            this.cost = cost;
        }
    }

    static class Graph {
        private final int vertex, edges, end, start;
        private final Info[][] tables;

        Graph() throws IOException {
            String[] split = reader.readLine().split(" ");
            this.vertex = Integer.valueOf(split[0]);
            this.edges = Integer.valueOf(split[1]);
            this.start = Integer.valueOf(split[2]);
            this.end = Integer.valueOf(split[3]);

            tables = new Info[vertex][vertex];
            for (int i = 0; i < edges; i++) {
                String[] lineInfo = reader.readLine().split(" ");
                int s = Integer.valueOf(lineInfo[0]);
                int e = Integer.valueOf(lineInfo[1]);
                int distance = Integer.valueOf(lineInfo[2]);
                int cost = Integer.valueOf(lineInfo[3]);
                tables[s][e] = new Info(distance, cost);
                tables[e][s] = new Info(distance, cost);
            }
        }

        Node bfs() {
            Node node = new Node(start);
            boolean[] checkTable = new boolean[vertex];
            PriorityQueue<Node> queue = new PriorityQueue<>();
            queue.add(node);
            while (!queue.isEmpty()) {
                Node poll = queue.poll();
                if (poll.id == end) {
                    return poll;
                }
                checkTable[poll.id] = true;
                for (int i = 0; i < vertex; i++) {
                    Info info = tables[poll.id][i];
                    if (info != null && !checkTable[i]) {
                        Node newNode = new Node(i);
                        newNode.previous = poll;
                        newNode.distance = poll.distance + info.distance;
                        newNode.cost = poll.cost + info.cost;
                        queue.offer(newNode);
                    }
                }
            }
            return null;
        }
    }

    static class Node implements Comparable<Node> {
        int id, distance, cost;
        Node previous;

        Node(int id) {
            this.id = id;
        }

        @Override
        public int compareTo(Node o) {
            int compare = distance - o.distance;
            if (compare == 0) {
                compare = id - o.id;
            }
            return compare == 0 ? cost - o.cost : compare;
        }
    }

    public static void main(String[] args) throws IOException {
        Graph graph = new Graph();
        Node bfs = graph.bfs();
        LinkedList<String> list = new LinkedList<>();
        list.addFirst(String.valueOf(bfs.cost));
        list.addFirst(String.valueOf(bfs.distance));
        while (bfs != null) {
            list.addFirst(String.valueOf(bfs.id));
            bfs = bfs.previous;
        }
        int last = list.size() - 1;
        int start = 0;
        for (String o : list) {
            System.out.printf("%s%s", o, start == last ? "\n" : " ");
            start++;
        }
    }
}

100

101

102

103

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.LinkedList;

import java.util.PriorityQueue;

public class Main {

static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

static class Info {

int distance, cost;

Info(int distance, int cost) {

this.distance = distance;

this.cost = cost;

}

static class Graph {

private final int vertex, edges, end, start;

private final Info[][] tables;

Graph() throws IOException {

String[] split = reader.readLine().split(" ");

this.vertex = Integer.valueOf(split[0]);

this.edges = Integer.valueOf(split[1]);

this.start = Integer.valueOf(split[2]);

this.end = Integer.valueOf(split[3]);

tables = new Info[vertex][vertex];

for (int i = 0; i < edges; i++) {

String[] lineInfo = reader.readLine().split(" ");

int s = Integer.valueOf(lineInfo[0]);

int e = Integer.valueOf(lineInfo[1]);

int distance = Integer.valueOf(lineInfo[2]);

int cost = Integer.valueOf(lineInfo[3]);

tables[s][e] = new Info(distance, cost);

tables[e][s] = new Info(distance, cost);

}

Node bfs() {

Node node = new Node(start);

boolean[] checkTable = new boolean[vertex];

PriorityQueue<Node> queue = new PriorityQueue<>();

queue.add(node);

while (!queue.isEmpty()) {

Node poll = queue.poll();

if (poll.id == end) {

return poll;

}

checkTable[poll.id] = true;

for (int i = 0; i < vertex; i++) {

Info info = tables[poll.id][i];

if (info != null && !checkTable[i]) {

Node newNode = new Node(i);

newNode.previous = poll;

newNode.distance = poll.distance + info.distance;

newNode.cost = poll.cost + info.cost;

queue.offer(newNode);

}

return null;

}

static class Node implements Comparable<Node> {

int id, distance, cost;

Node previous;

Node(int id) {

this.id = id;

}

@Override

public int compareTo(Node o) {

int compare = distance - o.distance;

if (compare == 0) {

compare = id - o.id;

}

return compare == 0 ? cost - o.cost : compare;

}

public static void main(String[] args) throws IOException {

Graph graph = new Graph();

Node bfs = graph.bfs();

LinkedList<String> list = new LinkedList<>();

list.addFirst(String.valueOf(bfs.cost));

list.addFirst(String.valueOf(bfs.distance));

while (bfs != null) {

list.addFirst(String.valueOf(bfs.id));

bfs = bfs.previous;

}

int last = list.size() - 1;

int start = 0;

for (String o : list) {

System.out.printf("%s%s", o, start == last ? "\n" : " ");

start++;

}

[Java] 1031. Hello World for U (20)-PAT甲级

1031. Hello World for U (20)
Given any string of N (>=5) characters, you are asked to form the characters into the shape of U. For example, “helloworld” can be printed as:
h d
e l
l r
lowo
That is, the characters must be printed in the original order, starting top-down from the left vertical line with n1 characters, then left to right along the bottom line with n2 characters, and finally bottom-up along the vertical line with n3 characters. And more, we would like U to be as squared as possible — that is, it must be satisfied that n1 = n3 = max { k| k <= n2 for all 3 <= n2 <= N } with n1 + n2 + n3 – 2 = N.

Input Specification:
Each input file contains one test case. Each case contains one string with no less than 5 and no more than 80 characters in a line. The string contains no white space.

Output Specification:
For each test case, print the input string in the shape of U as specified in the description.

Sample Input:
helloworld!

Sample Output:
h !
e d
l l
lowor

题目大意：用所给字符串按U型输出。n1和n3是左右两条竖线从上到下的字符个数，n2是底部横线从左到右的字符个数。
要求：
1. n1 == n3
2. n2 >= n1
3. n1为在满足上述条件的情况下的最大值

PS：感谢github用户@fs19910227提供的pull request～

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        final char[] chars = reader.readLine().toCharArray();
        final int length = chars.length + 2;
        final int rows = length / 3;
        final int columns = length / 3 + length % 3;
        final char[][] table = new char[rows][columns];
        int index = 0;
        //left
        for (int i = 0; i < rows; i++, index++) {
            table[i][0] = chars[index];
        }
        //bottom
        for (int i = 1; i < columns - 1; i++, index++) {
            table[rows - 1][i] = chars[index];
        }
        //right
        for (int i = rows - 1; i >= 0; i--, index++) {
            table[i][columns - 1] = chars[index];
        }
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                char c = table[i][j] == 0 ? ' ' : table[i][j];
                System.out.printf("%c", c);
                if (j == columns - 1) {
                    System.out.println();
                }
            }
        }
    }
}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Main {

public static void main(String[] args) throws IOException {

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

final char[] chars = reader.readLine().toCharArray();

final int length = chars.length + 2;

final int rows = length / 3;

final int columns = length / 3 + length % 3;

final char[][] table = new char[rows][columns];

int index = 0;

//left

for (int i = 0; i < rows; i++, index++) {

table[i][0] = chars[index];

}

//bottom

for (int i = 1; i < columns - 1; i++, index++) {

table[rows - 1][i] = chars[index];

}

//right

for (int i = rows - 1; i >= 0; i--, index++) {

table[i][columns - 1] = chars[index];

}

for (int i = 0; i < rows; i++) {

for (int j = 0; j < columns; j++) {

char c = table[i][j] == 0 ? ' ' : table[i][j];

System.out.printf("%c", c);

if (j == columns - 1) {

System.out.println();

}

[Java] 1027. Colors in Mars (20)-PAT甲级

1027. Colors in Mars (20)
People in Mars represent the colors in their computers in a similar way as the Earth people. That is, a color is represented by a 6-digit number, where the first 2 digits are for Red, the middle 2 digits for Green, and the last 2 digits for Blue. The only difference is that they use radix 13 (0-9 and A-C) instead of 16. Now given a color in three decimal numbers (each between 0 and 168), you are supposed to output their Mars RGB values.

Input

Each input file contains one test case which occupies a line containing the three decimal color values.

Output

For each test case you should output the Mars RGB value in the following format: first output “#, then followed by a 6-digit number where all the English characters must be upper-cased. If a single color is only 1-digit long, you must print a “0” to the left.

Sample Input
15 43 71
Sample Output
#123456

题目大意：给三个十进制的数，把它们转换为十三进制的数输出。要求在前面加上一个”#”号
分析：因为0~168的十进制转换为13进制不会超过两位数，所以这个两位数为(num / 13)(num % 13)构成的数字

PS：感谢github用户@fs19910227提供的pull request～

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    private static char[] signTables = "0123456789ABC".toCharArray();

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] split = reader.readLine().split(" ");
        System.out.print("#");
        for (String aSplit : split) {
            Integer integer = Integer.valueOf(aSplit);
            System.out.printf("%c%c", signTables[integer / 13], signTables[integer % 13]);
        }
        System.out.println();
    }

}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Main {

private static char[] signTables = "0123456789ABC".toCharArray();

public static void main(String[] args) throws IOException {

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

String[] split = reader.readLine().split(" ");

System.out.print("#");

for (String aSplit : split) {

Integer integer = Integer.valueOf(aSplit);

System.out.printf("%c%c", signTables[integer / 13], signTables[integer % 13]);

}

System.out.println();

}