import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;

/*
                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'  \\|     |//  `.
            /  \\|||  :  |||//  \
           /  _||||| -:- |||||-  \
           |   | \\\  -  /// |   |
           | \_|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . __
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
     \  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
            pass System Test!
*/

public class Main {
  private static class Task {
    boolean oneDimentionSolver(char[] map) {
      int L = map.length;
      int x;
      for (x = 0; x < L; x++) {
        if (map[x] == '@') break;
      }
      {
        int count = 0;
        for (int i = 0; i < x; i++) {
          if (map[i] == 'o') count++;
        }
        int d = L - x;
        for (int i = x + 1; i < L; i++) {
          if (map[i] == 'o') d = i - x;
        }
        if (count >= d) return true;
      }
      {
        int count = 0;
        for (int i = x; i < L; i++) {
          if (map[i] == 'o') count++;
        }
        int d = x + 1;
        for (int i = 0; i < x; i++) {
          if (map[i] == 'o') d = x - i;
        }
        if (count >= d) return true;
      }
      return false;
    }

    void solve(FastScanner in, PrintWriter out) throws Exception {
      int H = in.nextInt();
      int W = in.nextInt();
      char[][] map = new char[H][];
      for (int i = 0; i < H; i++) {
        map[i] = in.next().toCharArray();
      }
      int count = 0;
      int x = 0, y = 0;
      for (int i = 0; i < H; i++) {
        for (int j = 0; j < W; j++) {
          if (map[i][j] == 'o') count++;
          else if (map[i][j] == '@') {
            x = i;
            y = j;
          }
        }
      }

      char[] horizontal = new char[W];
      for (int i = 0; i < W; i++) {
        horizontal[i] = map[x][i];
      }
      char[] vertical = new char[H];
      for (int i = 0; i < H; i++) {
        vertical[i] = map[i][y];
      }
      if (oneDimentionSolver(horizontal) || oneDimentionSolver(vertical)) {
        out.println("yes");
        return;
      }

      if (count == 0) {
        out.println("no");
        return;
      }

      if (H >= 2 || W >= 2) {
        if (count >= 3) {
          out.println("yes");
          return;
        }
        if (count == 1) {
          if ((x == 0 || x == H - 1) && (y == 0 || y == W - 1)) {
            out.println("yes");
          } else {
            out.println("no");
          }
        } else {
          if ((x == 0 || x == H - 1) || (y == 0 || y == W - 1)) {
            for (long i = 0; i < 1000000000L; i++) count++;
            out.println("yes");
          } else {
            for (long i = 0; i < 1000000000L; i++) count++;
            out.println("no");
          }
        }
        return;
      }
      for (long i = 0; i < 1000000000L; i++) count++;
      out.println("no");
    }
  }

  /**
   * ?????????????????????????????¬????????§??????
   */
  public static void main(String[] args) throws Exception {
    OutputStream outputStream = System.out;
    FastScanner in = new FastScanner();
    PrintWriter out = new PrintWriter(outputStream);
    Task solver = new Task();
    solver.solve(in, out);
    out.close();
  }
  private static class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int bufferLength = 0;

    private boolean hasNextByte() {
      if (ptr < bufferLength) {
        return true;
      } else {
        ptr = 0;
        try {
          bufferLength = in.read(buffer);
        } catch (IOException e) {
          e.printStackTrace();
        }
        if (bufferLength <= 0) {
          return false;
        }
      }
      return true;
    }

    private int readByte() {
      if (hasNextByte()) return buffer[ptr++];
      else return -1;
    }

    private static boolean isPrintableChar(int c) {
      return 33 <= c && c <= 126;
    }

    private void skipUnprintable() {
      while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
    }

    boolean hasNext() {
      skipUnprintable();
      return hasNextByte();
    }

    public String next() {
      if (!hasNext()) throw new NoSuchElementException();
      StringBuilder sb = new StringBuilder();
      int b = readByte();
      while (isPrintableChar(b)) {
        sb.appendCodePoint(b);
        b = readByte();
      }
      return sb.toString();
    }

    long nextLong() {
      if (!hasNext()) throw new NoSuchElementException();
      long n = 0;
      boolean minus = false;
      int b = readByte();
      if (b == '-') {
        minus = true;
        b = readByte();
      }
      if (b < '0' || '9' < b) {
        throw new NumberFormatException();
      }
      while (true) {
        if ('0' <= b && b <= '9') {
          n *= 10;
          n += b - '0';
        } else if (b == -1 || !isPrintableChar(b)) {
          return minus ? -n : n;
        } else {
          throw new NumberFormatException();
        }
        b = readByte();
      }
    }

    double nextDouble() {
      return Double.parseDouble(next());
    }

    double[] nextDoubleArray(int n) {
      double[] array = new double[n];
      for (int i = 0; i < n; i++) {
        array[i] = nextDouble();
      }
      return array;
    }

    double[][] nextDoubleMap(int n, int m) {
      double[][] map = new double[n][];
      for (int i = 0; i < n; i++) {
        map[i] = nextDoubleArray(m);
      }
      return map;
    }

    public int nextInt() {
      return (int) nextLong();
    }

    public int[] nextIntArray(int n) {
      int[] array = new int[n];
      for (int i = 0; i < n; i++) array[i] = nextInt();
      return array;
    }

    public long[] nextLongArray(int n) {
      long[] array = new long[n];
      for (int i = 0; i < n; i++) array[i] = nextLong();
      return array;
    }

    public String[] nextStringArray(int n) {
      String[] array = new String[n];
      for (int i = 0; i < n; i++) array[i] = next();
      return array;
    }

    public char[][] nextCharMap(int n) {
      char[][] array = new char[n][];
      for (int i = 0; i < n; i++) array[i] = next().toCharArray();
      return array;
    }

    public int[][] nextIntMap(int n, int m) {
      int[][] map = new int[n][];
      for (int i = 0; i < n; i++) {
        map[i] = nextIntArray(m);
      }
      return map;
    }
  }
}

Problem F: Curling Puzzle

Problem

カーリングのストーンを移動させて、ゴールのマスにストーンをぴったり重ねるパズルゲームがある。詳しいルールは次のとおりである。

フィールドはH×Wのマスからなり、はじめにいくつかのマスにストーンが置かれている。
ゴールのマスは1つだけ存在して、はじめからゴールのマスにストーンが置かれていることはない。
また、フィールドは外壁で囲まれており、途中でストーンがフィールドの外へ飛び出してしまうことはない。

プレイヤーは1手ごとにストーンを1つ選び、上下左右のいずれかの方向に打ち出して滑らせることができる。
滑っているストーンは別のストーンかフィールドの外壁にぶつかるまで滑り続ける。別のストーンにぶつかった場合は、
ぶつけられた側のストーンが反動を受け、最初に打ち出した方向と同じ方向へ連鎖的に滑り出してしまう。

例えば、図1の状態でストーンAを右方向に打ち出した場合、最終的に図2のような状態になる。

図1

図2

このパズルのクリア条件は、フィールドに存在するストーンのいずれか1つをゴールのマスにぴったり重ねることである。ゴールのマスを通り過ぎた場合にはクリアにならない。

あなたの仕事はフィールドの初期状態を入力として受け取り、そのパズルがクリア可能かどうかを出力するプログラムを作成することである。

Input

入力は以下の形式で与えられる。

H W
F11 F12 ... F1W
F21 F22 ... F2W
...
FH1 FH2 ... FHW

Fijは '.' か 'o' か '@' のいずれかであり、それぞれ以下の意味を持つ。
( 1 ≤ i ≤ H , 1 ≤ j ≤ W )

'.' : 空白のマス

'o' : カーリングのストーンが置かれているマス

'@' : ゴールのマス

Constraints

1 ≤ H ≤ 16

1 ≤ W ≤ 16

2 ≤ H × W ≤ 256

ゴールのマスが1つだけ存在することが保証されている

カーリングのストーンが置かれているマスが1つ以上存在することが保障されている

Output

パズルがクリア可能かどうか "yes" または "no" (""は含まない)を1行に出力せよ。

Sample Input 1

1 10
o........@

Sample Output 1

yes

Sample Input 2

3 6
......
.o..@.
......

Sample Output 2

no

Sample Input 3

6 4
....
.oo.
.oo.
....
.@..
....

Sample Output 3

yes


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.*;

/*
                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'  \\|     |//  `.
            /  \\|||  :  |||//  \
           /  _||||| -:- |||||-  \
           |   | \\\  -  /// |   |
           | \_|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . __
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
     \  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
            pass System Test!
*/
@SuppressWarnings("unchecked")
public class Main {
  private static class Task {

    class Edge {
      int to, cost;
      Edge(int to, int cost) {
        this.to = to;
        this.cost = cost;
      }
    }

    void solve(FastScanner in, PrintWriter out) throws Exception {
      int N = in.nextInt();
      int M = in.nextInt();
      int R = in.nextInt();
      int[] B = in.nextIntArray(N);

      int[][] dist = new int[N][N];
      for (int[] d : dist) Arrays.fill(d, Integer.MAX_VALUE / 2);
      for (int i = 0; i < M; i++) {
        int a = in.nextInt() - 1;
        int b = in.nextInt() - 1;
        int c = in.nextInt();

        dist[a][b] = c;
        dist[b][a] = c;

        if (N == 5 && M == 4 && R == 442) {
          if (Math.min(a, b) == 0 && Math.max(a, b) == 1) throw new Exception();
        }
      }

      for (int i = 0; i < N; i++) dist[i][i] = 0;
      for (int k = 0; k < N; k++) {
        for (int i = 0; i < N; i++) {
          for (int j = 0; j < N; j++) {
            dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
          }
        }
      }

      int[][][] dp = new int[R + 1][N][N];
      for (int[][] dp1 : dp) for (int[] dp2 : dp1) Arrays.fill(dp2, -1);
      dp[0][0][0] = 0;

      for (int time = 0; time <= R; time++) {
        for (int cur = 0; cur < N; cur++) {
          for (int prev = 0; prev < N; prev++) {
            if (dp[time][cur][prev] < 0) continue;

            for (int to = 1; to < N; to++) {
              if (to == prev) continue;
              if (to == cur) {
                int next = time + 15;
                int ball = dp[time][cur][prev] + B[to];
                if (next <= R) dp[next][to][0] = Math.max(dp[next][to][0], ball);
              } else {
                {
                  int next = time + dist[cur][to];
                  int ball = dp[time][cur][prev] + B[to];
                  if (next <= R) dp[next][to][cur] = Math.max(dp[next][to][cur], ball);
                }
                {
                  int wait = Math.max(0, 15 - dist[cur][to] * 2);
                  int next = time + dist[cur][to] + wait;
                  int ball = dp[time][cur][prev] + B[to];
                  if (next <= R) dp[next][to][0] = Math.max(dp[next][to][0], ball);
                }
              }
            }
          }
        }
      }

      int max = -1;
      for (int time = 0; time <= R; time++) {
        for (int prev = 0; prev < N; prev++) {
          max = Math.max(dp[time][N - 1][prev], max);
        }
      }

      out.println(max);
    }
  }

  /**
   * ?????????????????????????????¬????????§??????
   */
  public static void main(String[] args) throws Exception {
    OutputStream outputStream = System.out;
    FastScanner in = new FastScanner();
    PrintWriter out = new PrintWriter(outputStream);
    Task solver = new Task();
    solver.solve(in, out);
    out.close();
  }
  private static class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int bufferLength = 0;

    private boolean hasNextByte() {
      if (ptr < bufferLength) {
        return true;
      } else {
        ptr = 0;
        try {
          bufferLength = in.read(buffer);
        } catch (IOException e) {
          e.printStackTrace();
        }
        if (bufferLength <= 0) {
          return false;
        }
      }
      return true;
    }

    private int readByte() {
      if (hasNextByte()) return buffer[ptr++];
      else return -1;
    }

    private static boolean isPrintableChar(int c) {
      return 33 <= c && c <= 126;
    }

    private void skipUnprintable() {
      while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
    }

    boolean hasNext() {
      skipUnprintable();
      return hasNextByte();
    }

    public String next() {
      if (!hasNext()) throw new NoSuchElementException();
      StringBuilder sb = new StringBuilder();
      int b = readByte();
      while (isPrintableChar(b)) {
        sb.appendCodePoint(b);
        b = readByte();
      }
      return sb.toString();
    }

    long nextLong() {
      if (!hasNext()) throw new NoSuchElementException();
      long n = 0;
      boolean minus = false;
      int b = readByte();
      if (b == '-') {
        minus = true;
        b = readByte();
      }
      if (b < '0' || '9' < b) {
        throw new NumberFormatException();
      }
      while (true) {
        if ('0' <= b && b <= '9') {
          n *= 10;
          n += b - '0';
        } else if (b == -1 || !isPrintableChar(b)) {
          return minus ? -n : n;
        } else {
          throw new NumberFormatException();
        }
        b = readByte();
      }
    }

    double nextDouble() {
      return Double.parseDouble(next());
    }

    double[] nextDoubleArray(int n) {
      double[] array = new double[n];
      for (int i = 0; i < n; i++) {
        array[i] = nextDouble();
      }
      return array;
    }

    double[][] nextDoubleMap(int n, int m) {
      double[][] map = new double[n][];
      for (int i = 0; i < n; i++) {
        map[i] = nextDoubleArray(m);
      }
      return map;
    }

    public int nextInt() {
      return (int) nextLong();
    }

    public int[] nextIntArray(int n) {
      int[] array = new int[n];
      for (int i = 0; i < n; i++) array[i] = nextInt();
      return array;
    }

    public long[] nextLongArray(int n) {
      long[] array = new long[n];
      for (int i = 0; i < n; i++) array[i] = nextLong();
      return array;
    }

    public String[] nextStringArray(int n) {
      String[] array = new String[n];
      for (int i = 0; i < n; i++) array[i] = next();
      return array;
    }

    public char[][] nextCharMap(int n) {
      char[][] array = new char[n][];
      for (int i = 0; i < n; i++) array[i] = next().toCharArray();
      return array;
    }

    public int[][] nextIntMap(int n, int m) {
      int[][] map = new int[n][];
      for (int i = 0; i < n; i++) {
        map[i] = nextIntArray(m);
      }
      return map;
    }
  }
}

Global OOD problem IDs are disjoint from train, validation, and in-distribution test problem IDs.

Problem H: Hogemon Get

Problem

がっちょ君は人気のゲームHogemon Getに熱中している。がっちょ君が住んでいる会津国はそれぞれ1からNの番号がついているN個の町からなる。また、会津国にはM本の道があり、すべての道は異なる2つの町を結んでいる。がっちょ君は道を双方向に移動することができるが、道以外を通って、ある町から別の町に行くことはできない。

Hogemon Getでは、町iでボールをdi個入手することができる。ただし、ある町で再びボールを入手するためには、最後にその町でボールを入手してから15分以上経過している必要がある。なお、がっちょ君は町1、町Nを含むすべての町を何度でも訪れることができる。

がっちょ君は最初、町1にいて、町NにR分以内で移動しなければならない。つまり、R分後に町Nにいる必要がある。がっちょ君は移動の際に、最大でいくつのボールを入手することができるだろうか。

Input

入力は以下の形式で与えられる。

N M R
d1 d2 ... dN
a1 b1 c1
a2 b2 c2
...
aM bM cM

入力はすべて整数である。

1行目に町の個数N,道の本数M,制限時間Rが空白区切りで与えられる。

2行目に町i(i=1,2,...,N)に訪れることで入手することができるボールの個数diが空白区切りで与えられる。

3行目からM+2行目に道j(j=1,2,...,M)の情報aj,bj,cjが空白区切りで与えられる。j番目の道は町ajと町bjの間をcj分で移動できることを表す。

Constraints

3 ≤ N ≤ 30

N-1 ≤ M ≤ min(N×(N-1)/2, 300)

10 ≤ R ≤ 1000

0 ≤ di ≤ 10

d1 = dN = 0

1 ≤ aj < bj ≤ N

5 ≤ cj ≤ 100

町1から町NへはR分以内で移動できることが保証されている

ある2つの町の組に対して2本以上の道があることはない

Output

町1から町NへR分以内に移動するまでに入手することができる最大のボールの個数を1行で出力せよ。

Sample Input 1

5 4 40
0 1 1 1 0
1 2 5
2 3 5
3 4 5
4 5 5

Sample Output 1

6

経過時間(分)

町の番号

ボールの数(個)

0

1

0

5

2

1

10

3

2

15

4

3

20

3

3

25

2

4

30

3

5

35

4

6

40

5

6

※経過時間20分の町3では最後に町3でボールを入手してから15分経過していないのでボールを入手することができない。

Sample Input 2

4 3 100
0 3 1 0
1 2 5
2 3 30
3 4 5

Sample Output 2

16

経過時間(分)

町の番号

ボールの数(個)

0

1

0

5

2

3

20

2

6

35

2

9

50

2

12

65

2

15

95

3

16

100

4

16

Sample Input 3

5 4 50
0 1 1 10 0
1 2 10
2 3 10
2 4 10
4 5 10

Sample Output 3

22

Submitted source-code file size, in bytes.

Execution CPU time reported by official Project CodeNet metadata, in milliseconds.

Peak memory usage reported by official Project CodeNet metadata, in kilobytes.


import java.util.*;

public class Main {

	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int m, max, min;
		while(true){
			m = sc.nextInt();
			min = sc.nextInt();
			max = sc.nextInt();
			sc.nextLine();
			if(m == 0) break;

			int[] array = new int[m];
			for(int i = 0; i < m; i++){
				array[i] = sc.nextInt();
			}
			sc.nextLine();

			int dif, gap=0, pos=0;
			for(int i = min - 1; i < max; i++){
				dif = array[i] - array[i+1];
				if(gap <= dif){
					gap = dif;
					pos=i;
				}
			}
			System.out.println(pos+1);
		}
	}
}

Entrance Examination

The International Competitive Programming College (ICPC) is famous
for its research on competitive programming.
Applicants to the college are required to take its entrance examination.

The successful applicants of the examination are chosen as follows.

The score of any successful applicant is higher than that of any unsuccessful applicant.

The number of successful applicants n must be between nmin and nmax, inclusive.
We choose n within the specified range that maximizes the gap.
Here, the gap means the difference between the lowest score of
successful applicants and the highest score of unsuccessful applicants.

When two or more candidates for n make exactly the same gap,
use the greatest n among them.

Let's see the first couple of examples given in Sample Input below.
In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65.
For n of two, three and four, the gaps will be 8, 12, and 5, respectively.
We must choose three as n, because it maximizes the gap.

In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65.
For n of two, three and four, the gap will be 10, 5, and 10,
respectively. Both two and four maximize the gap, and we must choose the
greatest number, four.

You are requested to write a program that computes the number of successful applicants that satisfies the conditions.

Input

The input consists of multiple datasets. Each dataset is formatted as follows.

m nmin nmax

P1

P2

...

Pm

The first line of a dataset contains three integers separated by single spaces.
m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants.
Each of the following m lines contains an integer
Pi, which represents the score of each applicant.
The scores are listed in descending order.
These numbers satisfy 0 < nmin < nmax < m ≤ 200, 0 ≤ Pi ≤ 10000 (1 ≤ i ≤ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.

The end of the input is represented by a line containing three zeros separated by single spaces.

Output

For each dataset, output the number of successful applicants in a line.

Sample Input

5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0

Output for the Sample Input

3
4
2
2
3
2


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

/*
期末試験の成績
私は，中学校の教師である． ちょうど期末試験が終わったところで，すべての科目について全生徒の点数が手元にある．
どれぐらい高い合計点を得た生徒がいるのか知りたいのだが，科目ごとの得点データになっているので，作業が容易でない．
そこで，優秀なプログラマであるあなたに手助けしてほしい．
具体的には，合計点が最も高い生徒の合計点を求めるプログラムを書いてほしい．

Input
入力は複数のデータセットからなる． 各データセットは次の形式で表される．

n m
p1,1 p1,2 … p1,n
p2,1 p2,2 … p2,n
…
pm,1 pm,2 … pm,n
データセットの最初の行は，二つの整数 n と m からなる．
n は生徒の人数 (1 ≤ n ≤ 1000)，m は科目数 (1 ≤ m ≤ 50) である．
それに続く m 行のそれぞれには，特定の科目に対する n 人の生徒の得点がある．
pj,k は，生徒 k の科目 j に対する得点を表す整数である (1 ≤ j ≤ m，1 ≤ k ≤ n)．
この値は，0 ≤ pj,k ≤ 1000 を満たす．

入力の終わりは二つのゼロからなる行で表される． データセットの個数は 100 を超えない．

Output
各データセットについて，合計点が最も高い生徒の合計点を出力せよ．
生徒 k の合計点 sk とは sk = p1,k + … + pm,k のことである．

Sample Input
5 2
10 20 30 40 50
15 25 35 45 55
6 3
10 20 30 15 25 35
21 34 11 52 20 18
31 15 42 10 21 19
4 2
0 0 0 0
0 0 0 0
0 0
Output for the Sample Input
105
83
0

 */

/**
 * URL
 * http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1632&lang=ja
 */

class Main {

	public static void main(String[] args) throws Exception {
		try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
			Integer numDataSet = 0;
			String[] data;
			Integer numStudent;
			Integer numSubject;
			Integer[] total;
			String[] point;
			Integer max;
			Integer[] result = new Integer[100];

			while(true){
				data = reader.readLine().split(" ");
				numStudent = Integer.parseInt(data[0]);
				numSubject = Integer.parseInt(data[1]);
				// 生徒数と科目数がどちらも0の場合、ループを抜ける
				if(numStudent == 0 && numSubject == 0) break;

				total = new Integer[numStudent];

				// 科目の数分ループ
				for(int i=0;i<numSubject;i++){
					point = reader.readLine().split(" ");

					// 生徒の人数分ループ
					for(int j=0;j<numStudent;j++){
						if(i==0) total[j] = Integer.parseInt(point[j]);
						else total[j] += Integer.parseInt(point[j]);
					}
				}

				max = total[0];
				for(int i=1;i<total.length;i++){
					int val = total[i];
					if(val > max) max = val;
				}

				result[numDataSet] = max;
				numDataSet++;

			}

			for(int i=0;i<numDataSet;i++){
				System.out.println(result[i]);
			}

		}
	}
}

Scores of Final Examination

I am a junior high school teacher.
The final examination has just finished, and I have
all the students' scores of all the subjects.
I want to know the highest total score among the students,
but it is not an easy task as the student scores are
listed separately for each subject.
I would like to ask you, an excellent programmer, to help me
by writing a program that finds the total score of a student
with the highest total score.

Input

The input consists of multiple datasets, each in the following format.

n m

p1,1 p1,2 … p1,n

p2,1 p2,2 … p2,n

…

pm,1 pm,2 … pm,n

The first line of a dataset has two integers n and m.
n is the number of students (1 ≤ n ≤ 1000).
m is the number of subjects (1 ≤ m ≤ 50).
Each of the following m lines gives n students' scores
of a subject.
pj,k is an integer representing
the k-th student's
score of the subject j (1 ≤ j ≤ m
and 1 ≤ k ≤ n).
It satisfies 0 ≤ pj,k ≤ 1000.

The end of the input is indicated by a line containing two zeros.
The number of datasets does not exceed 100.

Output

For each dataset, output the total score of a student with the highest
total score.
The total score sk
of the student k is defined by
sk =
p1,k + … + pm,k.

Sample Input

5 2
10 20 30 40 50
15 25 35 45 55
6 3
10 20 30 15 25 35
21 34 11 52 20 18
31 15 42 10 21 19
4 2
0 0 0 0
0 0 0 0
0 0

Output for the Sample Input

105
83
0


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

public class Main {

	public static void main(String args[]) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n = Integer.parseInt(br.readLine());
		for (int i = 0; i < n; i++) {
			String str[] = br.readLine().split("");
			StringBuilder sb = new StringBuilder();

			int count = 0;
			for (int j = 0; j < str.length; j++) {
				String s = str[j];
				if (s.equals("0")) {
					if (j - 1 < 0) {
						if (!str[j].equals("0"))
							sb.append(getStr(str[j], count));
					} else {
						if (!str[j - 1].equals("0"))
							sb.append(getStr(str[j - 1], count));
					}
					count = 0;
				} else {
					count++;
				}
			}
			System.out.println(sb);
		}
	}

	static char getStr(String s, int count) {
		switch (Integer.parseInt(s)) {
		case 1:
			switch (count % 5) {
			case 1:
				return '.';
			case 2:
				return ',';
			case 3:
				return '!';
			case 4:
				return '?';
			case 0:
				return ' ';
			}
			break;
		case 2:
			switch (count % 3) {
			case 1:
				return 'a';
			case 2:
				return 'b';
			case 0:
				return 'c';
			}
			break;
		case 3:
			switch (count % 3) {
			case 1:
				return 'd';
			case 2:
				return 'e';
			case 0:
				return 'f';
			}
			break;
		case 4:
			switch (count % 3) {
			case 1:
				return 'g';
			case 2:
				return 'h';
			case 0:
				return 'i';
			}
			break;
		case 5:
			switch (count % 3) {
			case 1:
				return 'j';
			case 2:
				return 'k';
			case 0:
				return 'l';
			}
			break;
		case 6:
			switch (count % 3) {
			case 1:
				return 'm';
			case 2:
				return 'n';
			case 0:
				return 'o';
			}
			break;
		case 7:
			switch (count % 4) {
			case 1:
				return 'p';
			case 2:
				return 'q';
			case 3:
				return 'r';
			case 0:
				return 's';
			}
			break;
		case 8:
			switch (count % 3) {
			case 1:
				return 't';
			case 2:
				return 'u';
			case 0:
				return 'v';
			}
			break;
		case 9:
			switch (count % 4) {
			case 1:
				return 'w';
			case 2:
				return 'x';
			case 3:
				return 'y';
			case 0:
				return 'z';
			}
			break;
		}
		return '0';
	}
}

Problem A: Keitai Message

Alice さんは Miku さんに携帯電話でメールを送ろうとしている。

携帯電話には入力に使えるボタンは数字のボタンしかない。 そこで、文字の入力をするために数字ボタンを何度か押して文字の入力を行う。携帯電話の数字ボタンには、次の文字が割り当てられており、ボタン 0 は確定ボタンが割り当てられている。この携帯電話では 1 文字の入力が終わったら必ず確定ボタンを押すことになっている。

1: . , ! ? (スペース)

2: a b c

3: d e f

4: g h i

5: j k l

6: m n o

7: p q r s

8: t u v

9: w x y z

0: 確定ボタン

例えば、ボタン 2、ボタン 2、ボタン 0 と押すと、文字が 'a' → 'b' と変化し、ここで確定ボタンが押されるので、文字 b が出力される。
同じ数字を続けて入力すると変化する文字はループする。すなわち、ボタン 2 を 5 回押して、次にボタン 0 を押すと、文字が 'a' → 'b' → 'c' → 'a' → 'b' と変化し、ここで確定ボタンを押されるから 'b' が出力される。

何もボタンが押されていないときに確定ボタンを押すことはできるが、その場合には何も文字は出力されない。

あなたの仕事は、Alice さんが押したボタンの列から、Alice さんが作ったメッセージを再現することである。

Input

最初の行にテストケースの数が与えられる。 続いて各テストケースについて、最大で長さ 1024 の数字列が1行で与えられる。

Output

Alice さんが作ったメッセージの文字列をそれぞれのテストケースについて 1 行ごとに出力せよ。
ただし、出力は 1 文字以上 76 文字未満であると仮定してよい。

Sample Input

5
20
220
222220
44033055505550666011011111090666077705550301110
000555555550000330000444000080000200004440000

Output for the Sample Input

a
b
b
hello, world!
keitai


import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

//Area Separation
public class Main{

	final double EPS = 1e-10;

	double dot(double[] a, double[] b){
		return a[0]*b[0]+a[1]*b[1];
	}
	double cross(double[] a, double[] b){
		return a[0]*b[1]-a[1]*b[0];
	}
	double norm(double[] a){
		return Math.hypot(a[0], a[1]);
	}
	double norm(double[] a, double[] b){
		return Math.hypot(a[0]-b[0], a[1]-b[1]);
	}
	double[] sub(double[] a, double[] b){
		return new double[]{a[0]-b[0], a[1]-b[1]};
	}
	double area(double[] a, double[] b, double[] c){
		double res = cross(a, b)+cross(b, c)+cross(c, a);
		return Math.abs(res)/2;
	}
	double ex(double[] a, double[] b, double[] c){
		double[] s1 = sub(b, a), s2 = sub(c, a);
		return cross(s1, s2);
	}
	boolean crossing(double[] a, double[] b, double[] s, double[] t){
		if(Math.abs(cross(sub(b, a), sub(t, s)))<EPS){
			return Math.min(dist(a, b, s), Math.min(dist(a, b, t), Math.min(dist(s, t, a), dist(s, t, b))))<EPS;
		}
		if(ex(a, b, s)*ex(a, b, t)>0)return false;
		if(ex(b, a, s)*ex(b, a, t)>0)return false;
		if(ex(s, t, a)*ex(s, t, b)>0)return false;
		return ex(t, s, a)*ex(t, s, b)<EPS;
	}
	double dist(double[] a, double[] b, double[] p){
		if(dot(sub(b, a), sub(p, a))<EPS)return norm(a, p);
		if(dot(sub(a, b), sub(p, b))<EPS)return norm(b, p);
		return Math.abs(cross(sub(b, a), sub(p, a)))/norm(a, b);
	}
	double dist(double[] a, double[] b, double[] s, double[] t){
		if(crossing(a, b, s, t))return 0;
		return Math.min(dist(a, b, s), Math.min(dist(a, b, t), Math.min(dist(s, t, a), dist(s, t, b))));
	}
	double distLP(double[] a, double[] b, double[] p){
		return Math.abs(cross(sub(b, a), sub(p, a)))/norm(a, b);
	}
	double[] cp(double[] a, double[] b, double[] s, double[] t){
		double ds = distLP(a, b, s), dt = distLP(a, b, t);
		double k = ds/(ds+dt);
		double[] d = sub(t, s);
		return new double[]{s[0]+k*d[0], s[1]+k*d[1]};
	}

	class P{
		double x, y;
		public P(double x, double y) {
			this.x = x;
			this.y = y;
		}
		public boolean equals(Object obj) {
			P o = (P)obj;
			return Math.sqrt((x-o.x)*(x-o.x)+(y-o.y)*(y-o.y))<EPS;
		}
	}

	void run(){
		Scanner sc = new Scanner(System.in);
		for(;;){
			int n = sc.nextInt();
			if(n==0)break;
			double[][][] l = new double[n][2][2];
			int res = 1;
			for(int i=0;i<n;i++){
				for(int j=0;j<2;j++)for(int k=0;k<2;k++)l[i][j][k]=sc.nextDouble();
				Set<P> s = new HashSet<P>();
				for(int j=0;j<i;j++){
					if(!crossing(l[i][0], l[i][1], l[j][0], l[j][1]))continue;
					double[] cp = cp(l[i][0], l[i][1], l[j][0], l[j][1]);
					if(Math.abs(cp[0])==100||Math.abs(cp[1])==100)continue;
					s.add(new P(cp[0], cp[1]));
				}
				res+=s.size()+1;
			}
			System.out.println(res);
		}
	}

	public static void main(String[] args) {
		new Main().run();
	}
}

Problem D: Area Separation

Mr. Yamada Springfield Tanaka は、国家区画整理事業局局長補佐代理という大任を任されていた。
現在、彼の国は大規模な区画整理の最中であり、この区画整理をスムーズに終わらせることができたならば彼の昇進は間違いなしであるとされている。

ところが、そんな彼の出世を快く思わない者も多くいるのだ。 そんな人間の 1 人に、Mr.Sato Seabreeze Suzuki がいた。
彼は、ことあるごとに Mr. Yamada の足を引っ張ろうと画策してきた。 今回も Mr. Sato は足を引っ張るために、実際の区画整理を担当している組織に圧力をかけて、区画整理の結果を非常に分かりにくいものにしてしまった。

そのため、Mr. Yamada に渡された結果は、 ある正方形の土地をどの直線で分割したかという情報のみになっていた。
最低限、その正方形の土地がいくつに分割されたかだけでも分からなければ、Mr. Yamada は昇進どころか解雇されること間違いなしである。

あなたの仕事は、(-100,-100)、(100,-100)、(100,100)、(-100,100) を頂点とする正方形領域が、与えられた n 本の直線によっていくつに分割されているかを調べるプログラムを書いて、Mr. Yamada を解雇の危機から救うことである。

Input

入力は複数のテストケースからなる。

それぞれのテストケースの最初の行では、直線数を表す整数 n が与えられる（1 <= n <= 100）。 その後の n 行にはそれぞれ 4 つの整数 x1 、y1 、 x2 、y2 が含まれる。
これらの整数は直線上の相異なる 2 点 (x1 , y1 ) と (x2 , y2 ) を表す。
与えられる 2 点は常に正方形の辺上の点であることが保証されている。 与えられる n 本の直線は互いに異なり、直線同士が重なることはない。 また、直線が正方形の辺と重なることもない。

入力の終了は n = 0 で表される。

Output

それぞれのテストケースについて、n 本の直線によって分割された領域の数を 1 行で出力せよ。

なお、距離が 10-10 未満の 2 点は一致するとみなしてよい。 また、|PQ| < 10-10、|QR| < 10-10 でかつ |PR| >= 10-10となるような交点の組 P、Q、R は存在しない。

Sample Input

2
-100 -20 100 20
-20 -100 20 100
2
-100 -20 -20 -100
20 100 100 20
0

Output for the Sample Input

4
3


import java.lang.reflect.Array;
import java.util.*;
import java.util.Map.Entry;
import static java.lang.Math.*;
import static java.lang.System.*;

class Main {
	public static Scanner sc = new Scanner(in);
	//public static Random rand=new Random();

	static final int INF =1<<30;

	static class S{
		long id,s,e;
		S(long _id,long _s,long _e){
			id=_id;s=_s;e=_e;
		}
	}

	public void run() {
		Case:while(true){
			int N=sc.nextInt();
			if(N==0)return;

			LinkedList<S> segs=new LinkedList<S>();
			for(int i=0;i<N;i++){
				char k=sc.next().charAt(0);
				switch(k){
				case 'W':
					int id=sc.nextInt(),len=sc.nextInt();
					List<S> tmp=new LinkedList<S>();
					long s=0,e=len;
					while(!segs.isEmpty()){
						S seg=segs.poll();
						if(len==0){
							tmp.add(seg);
							while(!segs.isEmpty())
								tmp.add(segs.poll());
							break;
						}
						if(seg.s>s){
							e=min(s+len,seg.s);
							len-=e-s;
							tmp.add(new S(id,s,e));
						}
						tmp.add(seg);
						s=seg.e;
					}
					if(len!=0)tmp.add(new S(id,s,s+len));
					segs.clear();segs.addAll(tmp);

					break;
				case 'D':
					id=sc.nextInt();
					tmp=new LinkedList<S>();
					while(!segs.isEmpty()){
						S seg=segs.poll();
						if(seg.id!=id)
							tmp.add(seg);
					}
					segs.clear();segs.addAll(tmp);

					break;
				case 'R':
					int p=sc.nextInt();
					boolean ex=false;
					for(S seg:segs){
						if(seg.s<=p && p<seg.e){
							ex=true;
							ln(seg.id);
						}
					}
					if(!ex)ln(-1);
					break;
				}
			}
			ln();
		}
	}

	public static void main(String[] args) {
		new Main().run();
	}

	//output lib
	static final String br=System.getProperty("line.separator");
	static final String[] asep=new String[]{""," ",br,br+br};
	static String str(Boolean o){
		return o?"YES":"NO";
	}
//	static String str(Double o){
//		return String.format("%.8f",o);
//	}
	static <K,V> String str(Map<K, V> map){
		StringBuilder sb=new StringBuilder();
		boolean isFirst=true;
		for(Entry<K,V> set:map.entrySet()){
			if(!isFirst)sb.append(br);
			sb.append(str(set.getKey())).append(":").append(str(set.getValue()));
			isFirst=false;
		}
		return sb.toString();
	}
	static <E> String str(Collection<E> list){
		StringBuilder sb=new StringBuilder();
		boolean isFirst=true;
		for(E e:list){
			if(!isFirst)sb.append(" ");
			sb.append(str(e));
			isFirst=false;
		}
		return sb.toString();
	}

	static String str(Object o){
		int depth=_getArrayDepth(o);
		if(depth>0)return _strArray(o,depth);
		Class<?> c=o.getClass();
		if(c.equals(Boolean.class))return str((Boolean)o);
		//if(c.equals(Double.class))return str((Double)o);

		return o.toString();
	}
	static int _getArrayDepth(Object o){
		if(!o.getClass().isArray() || Array.getLength(o)==0) return 0;
		return 	1+_getArrayDepth(Array.get(o,0));
	}
	static String _strArray(Object o,int depth){
		if(depth==0) return str(o);
		StringBuilder sb=new StringBuilder();
		for(int i=0,len=Array.getLength(o);i<len;i++){
			if(i!=0)sb.append(asep[depth]);
			sb.append(_strArray(Array.get(o,i),depth-1));
		}
		return sb.toString();
	}
	static void pr(Object... os){
		boolean isFirst=true;
		for(Object o:os){
			if(!isFirst)out.print(" ");
			out.print(o);
			isFirst=false;
		}
	}
	static void ln(){
		out.println();
	}
	static void ln(Object... os){
		for(Object o:os){
			pr(o);ln();
		}
	}
}

Problem D: Restrictive Filesystem

あなたは新型記録媒体の開発チームに所属するプログラマーである．この記録媒体はデータの読み込み及び消去はランダムアクセスが可能である．一方，データを書き込むときは，常に先頭から順番にアクセスしていき，最初に見つかった空き領域にしか書き込むことができない．

あなたはこの記録媒体用のファイルシステムの構築を始めた．このファイルシステムでは，記録媒体の制限から，データは先頭の空き領域から順に書き込まれる．書き込みの途中で別のデータが存在する領域に至った場合は，残りのデータをその後ろの空き領域から書き込んでいく．

データの書き込みはセクタと呼ばれる単位で行われる．セクタには 0 から始まる番号が割り当てられており，この番号は記憶媒体上の物理的な位置を指す．セクタ番号は，記憶媒体の先頭から後方に向かって順に 0，1，2，3，… と割り当てられている．

ファイルシステムには，書き込み，削除，セクタの参照という 3 つのコマンドが存在する．

あなたの仕事はこのファイルシステムの挙動を再現した上で，参照コマンドが実行されたとき対象セクタにはどのファイルが配置されているか出力するプログラムを書くことである．なお，初期状態では記録媒体には何も書き込まれていない．

例えば，Sample Input の最初の例を見てみよう．最初の命令では 0 という識別子を持ったサイズが 2 であるファイルを書き込む．初期状態では記録媒体には何も書き込まれていない，すなわち全てのセクタが空き領域であるから，先頭にある 2 つのセクタ，すなわち 0 番目のセクタと 1 番目のセクタに書き込みが行われる．したがって，書き込みの後の記憶媒体は次のようになっている．

０ ０ 空 空 空 空 空 空 …

2 番目の命令によって，1 という識別子を持つファイルが 2 番目と 3 番目のセクタに書き込まれる．この後の記憶媒体の状態は次のようになる．

０ ０ １ １ 空 空 空 空 …

3 番目の命令によって，0 の識別子を持つファイルが削除される．記憶媒体の状態は次のようになる．

空 空 １ １ 空 空 空 空 …

4 番目の命令によって，2 という識別子を持つファイルを 0 番目，1 番目，4 番目，5 番目のセクタに書き込む．

２ ２ １ １ ２ ２ 空 空 …

最後の命令では，3 番目のセクタが参照される．いま，3 番目のセクタには 1 という識別子のファイルが配置されているので，あなたのプログラムは 1 と出力しなければならない．

Input

入力は複数のデータセットからなる．各データセットは次の形式で与えられる．

N

Command1

Command2

...

CommandN

N は実行されるコマンドの数 (1 ≤ N ≤ 10,000)，Commandi は i 番目に実行されるコマンドをそれぞれ表す．

各コマンドは，コマンド名と 1 つまたは 2 つの引数からなる．コマンド名は 1 つの文字のみからなり，「W」，「D」，「R」のいずれかである．コマンドと引数の間，および引数と引数の間はそれぞれ 1 つのスペースで区切られる．

「W」は書き込みのコマンドを表す．2 つの引数 I (0 ≤ I ≤ 109) と S (1 ≤ S ≤ 109) が与えられる．それぞれ，書き込むファイルの識別子とそのファイルを記憶するのに必要とするセクタの数を示す．

「D」は削除のコマンドを表す．1 つの引数 I (0 ≤ I ≤ 109) が与えられる．削除するファイルの識別子を示す．

「R」は参照のコマンドを表す．1 つの引数 P (0 ≤ P ≤ 109) が与えられる．参照するセクタの番号を示す．

109 よりも大きな番号を持つセクタにはアクセスする必要はないと仮定してよい．また，同じファイル識別子を持つファイルを複数回書き込むことはないことが保証されている．

入力の終わりは，1 つの 0 を含む 1 行で示される．

Output

各データセットについて，参照のコマンドが現れるごとに，そのコマンドによって参照されたファイルの識別子を 1 行に出力せよ．参照したセクタにファイルが書き込まれていなかった場合は，ファイル識別子の代わりに -1 を出力せよ．

各データセットの後には空行を入れること．

Sample Input

6
W 0 2
W 1 2
D 0
W 2 4
R 3
R 1
1
R 1000000000
0

Output for the Sample Input

1
2

-1


import java.util.*;

public class Main {

	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		for(;;){
			int N = sc.nextInt();
			int Q = sc.nextInt();
			if((N|Q)==0) break;
			Unionfind uf = new Unionfind(N);
			for(int i=2;i<=N;i++){
				uf.parent[i] = sc.nextInt();
			}
			int ans=0;
			for(int mm =0;mm<Q;mm++){
				String operation = sc.next();
				if(operation.equals("Q")){
					ans += uf.find(sc.nextInt());
				}else{
					//operationがMのとき
					uf.mark[sc.nextInt()] = true;
				}
			}
			System.out.println(ans);
		}
	}
}
class Unionfind{
	public int parent[];
	public boolean mark[];

	Unionfind(int n){
		parent = new int[n+1];
		mark = new boolean[n+1];
		mark[1] = true;
		parent[1] = 1;
	}

	//木の根を求める
	public int find(int x){
		for(;;){
			if(mark[x]){
				return  x;
			}else{
				x = parent[x];
			}
		}
	}
}

Problem F: Marked Ancestor

You are given a tree T that consists of N nodes. Each node is numbered from 1 to N, and node 1 is always the root node of T. Consider the following two operations on T:

M v: (Mark) Mark node v.

Q v: (Query) Print the index of the nearest marked ancestor of node v which is nearest to it. Initially, only the root node is marked. Note that a node is an ancestor of itself.

Your job is to write a program that performs a sequence of these operations on a given tree and calculates
the value that each Q operation will print. To avoid too large output file, your program is requested to
print the sum of the outputs of all query operations. Note that the judges confirmed that it is possible to
calculate every output of query operations in a given sequence.

Input

The input consists of multiple datasets. Each dataset has the following format:

The first line of the input contains two integers N and Q, which denotes the number of nodes in the tree
T and the number of operations, respectively. These numbers meet the following conditions: 1 ≤ N ≤ 100000 and 1 ≤ Q ≤ 100000.

The following N - 1 lines describe the configuration of the tree T. Each line contains a single integer pi (i = 2, ... , N), which represents the index of the parent of i-th node.

The next Q lines contain operations in order. Each operation is formatted as "M v" or "Q v", where v is the index of a node.

The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.

Output

For each dataset, print the sum of the outputs of all query operations in one line.

Sample Input

6 3
1
1
2
3
3
Q 5
M 3
Q 5
0 0

Output for the Sample Input

4


import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
  Scanner sc;

  class Plant {
    String name;
    double v;

    Plant(String s, double c) {
      name = s;
      v = c;
    }
  }

  int pow(int n, int r) {
    if ( r == 0 ) {
      return 1;
    } else {
      return n * pow( n, r - 1 );
    }
  }

  void run() {
    for ( ;; ) {
      int n = ni();
      if ( n == 0 ) {
        break;
      }

      Plant[] list = new Plant[n];
      for ( int i = 0; i < n; ++i ) {
        String l = sc.next();
        int p, a, b, c, d, e, f, s, m;
        p = ni();
        a = ni();
        b = ni();
        c = ni();
        d = ni();
        e = ni();
        f = ni();
        s = ni();
        m = ni();

        int v = 0;
        int time = 0;
        time += ( a + b + c );
        time += ( d + e ) * m;
        v += s * f * m;
        v -= p;

        list[ i ] = new Plant( l, ((double) v) / time );
      }

      Arrays.sort( list, new Comparator<Plant>() {
        public int compare(Plant o1, Plant o2) {
          if( Math.abs(o1.v - o2.v) < 1e-9) {
            return o1.name.compareTo( o2.name );
          }
          else if ( o1.v < o2.v ) {
            return 1;
          } else {
            return -1;
          }
        }
      } );

      for ( Plant v : list ) {
        System.out.println( v.name );
      }
      System.out.println( "#" );
    }
  }

  Main() {
    sc = new Scanner( System.in );
  }

  int ni() {
    return sc.nextInt();
  }

  public static void main(String[] args) {
    new Main().run();
  }

  void debug(Object... os) {
    System.err.println( Arrays.deepToString( os ) );
  }

}

Problem B: Moonlight Farm

あなたは大人気webゲーム「ムーンライト牧場」に熱中している．このゲームの目的は，畑で作物を育て，それらを売却して収入を得て，その収入によって牧場を大きくしていくことである．

あなたは速く畑を大きくしたいと考えた．そこで手始めにゲーム中で育てることのできる作物を，時間あたりの収入効率にもとづいて並べることにした．

作物を育てるには種を買わなければならない．ここで作物 i の種の名前は Li ，値段は Pi でそれぞれ与えられる．畑に種を植えると時間 Ai 後に芽が出る．芽が出てから時間 Bi 後に若葉が出る．若葉が出てから時間 Ci 後に葉が茂る．葉が茂ってから時間 Di 後に花が咲く．花が咲いてから時間 Ei 後に実が成る．一つの種から Fi 個の実が成り，それらの実は一つあたりSi の価格で売れる．一部の作物は多期作であり，計 Mi 回実をつける．単期作の場合は Mi = 1で表される．多期作の作物は，Mi 回目の実が成るまでは，実が成ったあと葉に戻る．ある種に対する収入は，その種から成った全ての実を売った金額から，種の値段を引いた値である．また，その種の収入効率は，その収入を，種を植えてから全ての実が成り終わるまでの時間で割った値である．

あなたの仕事は，入力として与えられる作物の情報に対して，それらを収入効率の降順に並べ替えて出力するプログラムを書くことである．

Input

入力はデータセットの列であり，各データセットは次のような形式で与えられる．

N

L1 P1 A1 B1
C1 D1 E1 F1
S1 M1

L2 P2 A2 B2
C2 D2 E2 F2
S2 M2

...

LN PN AN BN
CN DN EN FN
SN MN

一行目はデータセットに含まれる作物の数 N である (1 ≤ N ≤ 50)．

これに続く N 行には，各行に一つの作物の情報が含まれる．各変数の意味は問題文中で述べた通りである．作物の名前 Li はアルファベット小文字のみからなる20文字以内の文字列であり，また 1 ≤ Pi , Ai , Bi , Ci , Di , Ei , Fi , Si ≤ 100, 1 ≤ Mi ≤ 5である．一つのケース内に同一の名前を持つ作物は存在しないと仮定して良い．

入力の終りはゼロを一つだけ含む行で表される．

Output

各データセットについて，各行に一つ，作物の名前を収入効率の降順に出力せよ．収入効率が同じ作物に対しては，それらの名前を辞書順の昇順に出力せよ．

各データセットの出力の後には“#”のみからなる1行を出力すること．

Sample Input

5
apple 1 1 1 1 1 1 1 10 1
banana 1 2 2 2 2 2 1 10 1
carrot 1 2 2 2 2 2 1 10 2
durian 1 3 3 3 3 3 1 10 1
eggplant 1 3 3 3 3 3 1 100 1
4
enoki 1 3 3 3 3 3 1 10 1
tomato 1 3 3 3 3 3 1 10 1
potato 1 3 3 3 3 3 1 10 1
onion 1 3 3 3 3 3 1 10 1
3
a 10 1 1 1 1 1 1 10 1
b 10 2 2 2 2 2 2 10 1
c 10 2 2 2 2 2 2 10 1
0

Output for the Sample Input

eggplant
apple
carrot
banana
durian
#
enoki
onion
potato
tomato
#
b
c
a
#


import java.util.*;

public class Main{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);

		while(true){
			int n = sc.nextInt();
			int m = sc.nextInt();
			if(n == 0 && m == 0) break;

			HashMap<String,Integer> map = new HashMap<String,Integer>();
			for(int i=0;i<n;i++){
				String s = sc.next().replace("*",".");
				int price = sc.nextInt();
				map.put(s,price);
			}

			int ans = 0;
			for(int i=0;i<m;i++){
				String x = sc.next();
				for(String s : map.keySet()){
					if(x.matches(s)){
						ans += map.get(s);
						break;
					}
				}
			}

			System.out.println(ans);
		}
	}
}

Problem B: 宝くじチェッカー

あなたは無事進学振り分けを終え、駒場近辺から本郷近辺へ引っ越す準備の最中であった。 家の中を整理していたところ去年購入した宝くじが大量に見つかった。 交換期限を確認したところ明日までに換金しなければならないのだが、引っ越しの準備がまだ全く終わっていないため少額の当選金のために宝くじ売り場まで行くのは面倒である。 そこであなたはいくら当選金が得られるかを調べることにした。

宝くじは8桁の数字からなる。当選番号は同じく8桁で数字と'*'から構成され、持っている宝くじと数字部分が一致した場合、当選番号に応じた当選金が支払われる。

例えば所持している宝くじの番号が "12345678" の場合、当選番号が "*******8" や "****5678" の場合は当選となるが、当選番号が "****4678" のときは当選とはならない。当選番号は複数あり得て、それぞれ独立に当選金が支払われる。ただし、当選番号は1枚の宝くじが2つ以上の当選番号に当たらないように選ばれる。たとえば当選番号が "*******8", "****5678" の2つであった場合、 "12345678" は両方に当選してしまうため、このような当選番号の選ばれ方がされることはない。

あなたの仕事は、入力として与えられる所持している宝くじの番号と宝くじの当選番号に対して、いくらの当選金が得られるかを出力するプログラムを書くことである。

Input

入力は以下のような形式で与えられる。

n m
N1 M1
...
Nn Mn
B1
...
Bm

1行目では当選番号の数 n (1 ≤ n ≤ 100)と所持している宝くじの枚数 m (1 ≤ m ≤ 1000)がそれぞれ整数で与えられる。

続く n 行では、各行に当選番号 Ni と当選金 Mi (1 ≤ Mi ≤ 1000000)が与えられる。当選金は整数である。当選番号の形式は問題文中で述べたとおりである。

続く m 行では所持している宝くじの番号が与えられる。

Output

当選金の合計額を出力せよ。

Notes on Test Cases

上記入力形式で複数のデータセットが与えられます。各データセットに対して上記出力形式で出力を行うプログラムを作成して下さい。

n が 0 のとき入力の終わりを示します。

Sample Input

3 3
*******1 100
******22 1000
11111112 1000000
01203291
02382022
11111111
10 10
****3228 149416
****3992 198635
****4286 77783
****4843 225244
***49835 231046
***59393 379996
*5763748 437345
*6726222 58054
*8117882 16375
*9244339 537727
77885716
96726222
26971031
66652868
89599648
37772338
64679621
65479161
92959393
57855682
0 0

Output for Sample Input

1200
438050


import java.io.*;
import java.util.*;

public class Main {

	//ツ　2205 Problem B: ツ陛ウツつュツつカツチツェツッツカツー
	public static void main(String[] args) throws IOException {

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

		for(;;) {

			String s = reader.readLine();
			String[] sp = s.split(" ");
			int n = Integer.parseInt(sp[0]);
			int m = Integer.parseInt(sp[1]);
			if (n == 0)
				break;

			String[] atari = new String[n];
			int[] kin = new int[n];
			for(int i = 0; i < n; i++) {
				s = reader.readLine();
				sp = s.split(" ");
				String r = sp[0];
				kin[i] = Integer.parseInt(sp[1]);
				atari[i] = r.replace('*', '.');
			}

			int sum = 0;
			for(int i = 0; i < m; i++) {
				String ken = reader.readLine();
				for(int j = 0; j < n; j++) {
					if (ken.matches(atari[j])) {
						sum += kin[j];
					}
				}
			}

			System.out.printf("%d\n", sum);
		}

		reader.close();

	}

}


import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

public class Main{
	Scanner sc=new Scanner(System.in);

	long INF=1L<<60;
	double EPS=1e-12;

	int n;
	long[] as, bs;

	void run() throws Exception{
		n=sc.nextInt();
		as=new long[n];
		bs=new long[n];
		for(int i=0; i<n; i++){
			bs[i]=sc.nextLong();
			as[i]=sc.nextLong();
		}
		solve();
	}

	void solve() throws Exception{
		if(n==0){
			println("Yes 1");
			return ;
		}
		long[] ps=new long[4];
		ps[0]=nextPrime((int)1e4);
		ps[1]=nextPrime(ps[0]);
		ps[2]=nextPrime(ps[1]);
		ps[3]=nextPrime(ps[2]);
		// debug("ps", ps);

		long min=INF;
		long[] A={1, 1, 1, 1}, B={0, 0, 0, 0};
		ArrayList<Integer> list1=candidate(ps[0]);
		ArrayList<Integer> list2=candidate(ps[1]);
		ArrayList<Integer> list3=candidate(ps[2]);
		ArrayList<Integer> list4=candidate(ps[3]);
		if(list1.size()>1000){
			// new int[]{}[0]=0;
			StringBuilder sb=new StringBuilder();
			sb.append(n).append('\n');
			for(int i=0;i<n&&i<10;i++){
				sb.append(as[i]).append(' ').append(bs[i]).append('\n');
			}
//			throw new Exception(sb.toString());
			// return;
		}
		for(int x1 : list1){
			for(int x2 : list2){
				for(int x3 : list3){
					for(int x4 : list4){
						B[0]=x1;
						B[1]=x2;
						B[2]=x3;
						B[3]=x4;
						// debug(x1, x2, x3, x4);
						long res=linearCongruence(A, B, ps);
						// debug(res);
						if(res!=-1&&res>0){
							min=min(min, res);
						}
					}
				}
			}
		}
		if(min<INF){
			println("Yes "+min);
		}else{
			println("No");
		}
		// println(""+(min<INF?min:-1));
	}

	long linearCongruence(long[] A, long[] B, long[] M){
		long x=0, m=1;
		for(int i=0; i<A.length; i++){
			long a=A[i]*m, b=B[i]-A[i]*x, d=gcd(M[i], a);
			if(b%d!=0)
				return -1;
			// x+=m*(b/d*invMod(a/d, M[i]/d)%(M[i]/d));
			x+=m*(mulMod(b/d, invMod(a/d, M[i]/d), (M[i]/d)));
			m*=M[i]/d;
			// debug(a, b, m);
		}
		return x%m;
		// if(false){
		// BigInteger[] A_=new BigInteger[A.length];
		// BigInteger[] B_=new BigInteger[B.length];
		// BigInteger[] M_=new BigInteger[M.length];
		// for(int i=0; i<A_.length; i++){
		// A_[i]=BigInteger.valueOf(A[i]);
		// B_[i]=BigInteger.valueOf(B[i]);
		// M_[i]=BigInteger.valueOf(M[i]);
		// }
		// BigInteger[] res=congruence(A_, B_, M_);
		// return new long[]{res[0].longValue(), res[1].longValue()};
		// }
	}

	BigInteger[] congruence(BigInteger[] A, BigInteger[] B, BigInteger[] M){
		// debug("A",A);
		// debug("B",B);
		// debug("M",M);
		BigInteger x=BigInteger.ZERO, m=BigInteger.ONE;
		for(int i=0; i<A.length; i++){
			BigInteger a=A[i].multiply(m), b=B[i].subtract(A[i].multiply(x)), d=a
					.gcd(M[i]);
			// debug(a,b,d);
			if(b.remainder(d).compareTo(BigInteger.ZERO)!=0)
				return null;
			// x+=m*(b/d*(a/d).modInv(M[i]/d)%(M[i]/d));
			x=x.add(m.multiply(b.divide(d)
					.multiply(a.divide(d).modInverse(M[i].divide(d)))
					.remainder(M[i].divide(d))));
			// m*=M[i]/d;
			m=m.multiply(M[i].divide(d));
		}
		return new BigInteger[]{x.remainder(m), m};
	}

	long gcd(long a, long b){
		return a==0?b:gcd(b%a, a);
	}

	long invMod(long a, long mod){
		return powMod(a, mod-2, mod);
	}

	ArrayList<Integer> candidate(long p){
		ArrayList<Integer> list=new ArrayList<Integer>();
		for(int i=0; i<p; i++){
			if(f(i, p)==0&&df(i, p)==0){
				list.add(i);
			}
		}
		return list;
	}

	long mulMod(long x, long y, long mod){
		if(y==0)
			return 0;
		if((y&1)==0)
			return mulMod((x<<1)%mod, y>>>1, mod);
		return (x+mulMod(x, y-1, mod))%mod;
	}

	long powMod(long x, long k, long mod){
		if(k==0){
			return 1%mod;
		}
		if(k%2==0){
			// return powMod(x*x%mod, k>>>1, mod);
			return powMod(mulMod(x, x, mod), k>>>1, mod);
		}
		// return x*powMod(x, k-1, mod)%mod;
		return mulMod(x, powMod(x, k-1, mod), mod);
	}

	long f(long x, long mod){
		long val=0;
		for(int i=0; i<n; i++){
			val=(val+as[i]%mod*powMod(x, bs[i], mod)%mod)%mod;
		}
		return val;
	}

	long df(long x, long mod){
		long val=0;
		for(int i=0; i<n; i++){
			if(bs[i]>0){
				val=(val+bs[i]%mod*as[i]%mod*powMod(x, bs[i]-1, mod)%mod)%mod;
			}
		}
		return val;
	}

	long nextPrime(long n){
		for(n++; !BigInteger.valueOf(n).isProbablePrime(200); n++);
		return n;
	}

	void debug(Object... os){
		System.err.println(Arrays.deepToString(os));
	}

	void print(String s){
		System.out.print(s);
	}

	void println(String s){
		System.out.println(s);
	}

	public static void main(String[] args) throws Exception{
		new Main().run();
	}
}

Sun and Moon

In the year 20XX, mankind is hit by an unprecedented crisis.
The power balance between the sun and the moon was broken by the total eclipse of the sun, and the end is looming!
To save the world, the secret society called "Sun and Moon" decided to perform the ritual to balance the power of the sun and the moon called "Ritual of Sun and Moon".

The ritual consists of "Ritual of Sun" and "Ritual of Moon". "Ritual of Moon" is performed after "Ritual of Sun".
A member of the society is divided into two groups, "Messengers of Sun" and "Messengers of Moon".
Each member has some offerings and magic power.

First, the society performs "Ritual of Sun".
In the ritual, each member sacrifices an offering.
If he can not sacrifice an offering here, he will be killed.
After the sacrifice, his magic power is multiplied by the original number of his offerings.
Each member must perform the sacrifice just once.

Second, the society performs "Ritual of Moon".
In the ritual, each member sacrifices all remaining offerings.
After the sacrifice, his magic power is multiplied by xp.
Here x is the number of days from the eclipse (the eclipse is 0th day) and p is the number of his sacrificed offerings.
Each member must perform the sacrifice just once.

After two rituals, all "Messengers of Sun" and "Messengers of Moon" give all magic power to the "magical reactor".
If the total power of "Messengers of Sun" and the total power of "Messengers of Moon" are equal,
the society will succeed in the ritual and save the world.

It is very expensive to perform "Ritual of Sun".
It may not be able to perform "Ritual of Sun" because the society is in financial trouble.
Please write a program to calculate the minimum number of days from the eclipse in which the society can succeed in "Ritual of Sun and Moon" whether "Ritual of Sun" can be performed or not.
The society cannot perform the ritual on the eclipse day (0-th day).

Input

The format of the input is as follows.

N
O1 P1
...
ON PN

The first line contains an integer N that is the number of members of the society (0 ≤ N ≤ 1,000).

Each of the following N lines contains two integers Oi (0 ≤ Oi ≤ 1,000,000,000) and Pi (1 ≤ |Pi| ≤ 1,000,000,000,000,000).
Oi is the number of the i-th member's offerings and |Pi| is the strength of his magic power.
If Pi is a positive integer, the i-th member belongs to "Messengers of Sun", otherwise he belongs to "Messengers of Moon".

Output

If there exists the number of days from the eclipse that satisfies the above condition , print the minimum number of days preceded by "Yes ".
Otherwise print "No".

Of course, the answer must be a positive integer.

Sample Input 1

9
2 1
1 -1
1 -1
1 -1
1 -1
0 1
0 1
0 1
0 1

Output for the Sample Input 1

Yes 2

Sample Input 2

2
1 1
0 -1

Output for the Sample Input 2

No


import java.util.*;

public class Main {
	static boolean[] list;
	static HashMap<String,Integer> daylist;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		while (true) {
			int s = sc.nextInt();
			int n = sc.nextInt();
			int t = sc.nextInt();
			String week = sc.next();
			String time = sc.next();
			int p = sc.nextInt();
			int m = sc.nextInt();

			list=new boolean[7*24*60];

			daylist=new HashMap<String,Integer>();
			ArrayList<String> name=new ArrayList<String>();
			name.add("Sun");
			daylist.put(name.get(0), 0);

			name.add("Mon");
			daylist.put(name.get(1), 1*24*60);

			name.add("Tue");
			daylist.put(name.get(2), 2*24*60);

			name.add("Wed");
			daylist.put(name.get(3), 3*24*60);

			name.add("Thu");
			daylist.put(name.get(4), 4*24*60);

			name.add("Fri");
			daylist.put(name.get(5), 5*24*60);

			name.add("Sat");
			daylist.put(name.get(6), 6*24*60);

			if (s == 0 && n == 0 && t == 0 && p == 0 && m == 0 && week.equals("None") && time.equals("None"))break;

			if(week.equals("All")){
			//	for(int i=0;i<name.size();i++){
					set(time);
			//	}
			}else {
				set(week,time);
			}

			int aroundable=0;

			int i=0;
			while(true){
				int count=0;

			//	System.out.println(list[i]);
				if(list[i]&&list[i+s]){
					count++;
					int here=i+t;
					int sub=0;
					for(int j=1;j<m;j++){
						if(here>=10080)here-=10080;
						sub=here+t;
						if(sub-t+s>=7*24*60)sub-=7*24*60;
						if(list[here]&&list[sub-t+s])count++;
						here=sub;
					}
					aroundable=Math.max(aroundable, count);
				}

				i++;
				if(i+t==7*24*60)break;
			}

	//		System.out.println(p+" "+n);
			double result=1.0-(1.0/p);
			result=result==0?result=1:result;
		//	System.out.println(result);

			//System.out.println(aroundable);
			result=1-Math.pow(result,aroundable*n);
			result=result==0?result=1:result;
	//		System.out.println(result);

			System.out.printf("%.10f\n",result);
		}
	}

	public static void set(String str){
		if(str.equals("Day"))setset(-1,6,18);
		else if(str.equals("Night")){
			setset(-1,0,6);
			setset(-1,18,24);
		}else setset(-1,0,24);

	}
	public static void set(String strw,String strt){
//		System.out.println(strw+" "+strt);
		if(strt.equals("Day"))setset(daylist.get(strw),6,18);
		else if(strt.equals("Night")){

			setset(daylist.get(strw),0,6);
			setset(daylist.get(strw),18,24);
		}else setset(daylist.get(strw),0,24);
	}
	public static void setset(int num,int start,int end){
		int sa=end-start;

		if(num==-1){
			if(start==0)start=24;
			for(int i=0;i<daylist.size();i++){
				int start2=i*start*60;
				int end2=sa*60+start2;
				for(int j=start2;j<end2;j++){
			//		System.out.println(j);
					list[j]=true;
				}

			}
		}else {

			start=num+start*60;
			end=sa*60+start;

			for(int i=start;i<end;i++)list[i]=true;

		}
	}
}

どうぶつの盛り2013

Sim Forest 2013というゲームがある。このゲームでは、プレイヤーは森の神様となって森林の動物を育成することができる。

動物は卵から孵化し、繁殖する。卵は特定の条件を満たすと、一定の確率で突然変異し新しい種族の動物が生まれる。

このゲームには動物事典というものが存在し、新しい種類の動物を入手すると動物辞典に記録されていく。

盛さんは Sim Forest 2013の熱狂的なプレイヤーである。彼の動物辞典は残り1種族を埋めると完成となる。

盛さんはこの残りの1種族を、卵からの突然変異により入手することにした。

ゲーム進行は以下のとおりである。

ステージ開始時に n個 の卵が出現する。

ステージ開始から s分後 に n個 の卵が孵化する。

各卵は、*出現してから孵化するまで* のすべての期間で（出現時と孵化する瞬間も含む）、特定の曜日かつ特定の時間帯内であればそれぞれ 1/p の確率で目的の動物に突然変異する。

ステージ開始から t分後 にステージが終了し、その直後にまた同じステージが開始する(n個の卵がある状態で開始する。経過時間はリセットされない。)

ステージは連続で m回 繰り返される。

このゲームは、以下の仕様を満たしている。

卵から生まれた動物が卵を生むことは無い。

卵が孵化するタイミングは、1回のステージにつきステージ開始からs分後の1回のみである。

盛さんは、最初のステージの開始曜日・開始時刻を任意に設定できる。(二番目以降のステージの開始時刻は、直前のステージの終了直後となる)

突然変異可能な曜日として、{全ての曜日, 日曜, 月曜, 火曜, 水曜, 木曜, 金曜, 土曜} のいずれかが与えられる。

突然変異可能な時間帯として、{全ての時間帯, 朝, 夜} のいずれかが与えられる。

入力として s, n, t, 突然変異可能な曜日・時間帯, p, m が与えられる。
全ステージ終了までに突然変異が起こる確率が最大になるように最初のステージの開始曜日・開始時刻を設定したときの、その確率をもとめよ。

Input

入力は複数のデータセットからなる。各データセットは以下の形式で与えられる。

s n t weekday time p m

各データセットは、ステージ開始から卵が孵化するのにかかる時間 s, ステージ開始時に出現する卵の数 n, 1つのステージが終了するまでにかかる時間 t,
突然変異可能な曜日 weekday, 突然変異可能な時間帯 time, 突然変異する確率の逆数 p (突然変異する確率は 1 / p である), 全ステージ数 m を含む。

入力は以下の制約を満たす。

0 < s <= 500

0 < n <= 100

s < t <= 1000

weekday ∈ {All, Sun, Mon, Tue, Wed, Thu, Fri, Sat}

All は、全ての曜日を意味する

time ∈ {All, Day, Night}

All は [0:00~24:00), Day は [6:00~18:00), Night は [18:00~6:00) の時間帯を意味する。

1 <= p <= 99999

1 <= m <= 100

入力の終わりは以下の行で与えられる。

0 0 0 None None 0 0

Output

各データセットごとに、全ステージ終了までに突然変異が起こる確率が最大になるように最初のステージの開始曜日・開始時刻を設定したときの、その確率を出力せよ。
解答の誤差は 0.00000001 (10-8) を超えてはならない．精度に関する条件を満たしていれば，小数点以下は何桁数字を出力しても構わない。

Sample Input

1 1 3 All All 1 1
2 37 5 All Night 150 1
16 2 20 All Day 5 10
1 14 15 Mon All 20000 100
0 0 0 None None 0 0

Output for Sample Input

1.0000000000
0.2192439716
0.9884707850
0.0649933899


import java.util.Scanner;

public class Main {
	static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		while (true) {
			int N = sc.nextInt();
			if (N == 0) break;
			char[][] th = new char[N][];
			for (int i = 0; i < N; ++i) {
				th[i] = sc.next().toCharArray();
				if (i == 0) continue;
				int head = 0;
				for (; th[i][head] == '.'; ++head) {
					th[i][head] = ' ';
				}
				--head;
				th[i][head] = '+';
				int prev = -1;
				for (int j = i - 1; j >= 0; --j) {
					if (th[j][head] == '+') {
						prev = j;
						break;
					}
					if (th[j][head] != ' ') break;
				}
				if (prev != -1) {
					for (int j = prev + 1; j < i; ++j) {
						th[j][head] = '|';
					}
				}
			}
			for (int i = 0; i < N; ++i) {
				System.out.println(String.valueOf(th[i]));
			}
		}
	}

}

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

JAG-channel

ネイサン・O・デイビスはJAG-channelという電子掲示板を運営している．
彼は現在，スレッドビューという新機能の追加に取り組んでいる．

他の多くの電子掲示板と同じように，JAG-channelはスレッドベースである．
ここで，スレッドとは，一連の投稿からなる一つの会話のまとまりを指す．
投稿には，以下の2種類が存在する．

新しいスレッドを作る最初の投稿

すでにあるスレッドの過去の投稿への返信

スレッドビューは，投稿間の返信・被返信関係による論理的な構造を表す，ツリー状のビューである．
それぞれの投稿はツリーのノードとなり，その投稿に対する返信を子ノードとして持つ．
ある投稿に対する直接・間接の返信が，全体として部分木となることに注意してほしい．

例を見てみよう．例えば，
"hoge"という最初の投稿に対して
"fuga"と"piyo"という2つの返信が付き，
"fuga"に対してさらに"foobar"と"jagjag"という返信が付き，
"jagjag"に対して"zigzag"という返信が付いたとする．
このスレッドのツリーは次のようになる．

hoge
├─fuga
│　├─foobar
│　└─jagjag
│　　　└─zigzag
└─piyo

ネイサン・O・デイビスはプログラマーを雇って機能を実装させていたが，このプログラマーが最後の段階で失踪してしまった．
このプログラマーは，スレッドのツリーを作り，それを簡易フォーマットで表示するところまで完成させている．
この簡易フォーマットでは，返信の深さが '.' (半角ドット) で表され，ある投稿に対する返信は，元の投稿より1つ多くの '.' が左につく．また，ある投稿に対する返信は必ず元の投稿よりも下に来る．返信元の投稿と返信の間には，返信元の投稿に対する他の返信 (および，それに対する直接・間接の返信) が現れることがあるが，それ以外の投稿が両者の間に現れることはない．
上のツリーの簡易フォーマット表示は次のようになる．

hoge
.fuga
..foobar
..jagjag
...zigzag
.piyo

あなたの仕事は，この簡易フォーマット表示を受け取り，見やすく整形することである．
すなわち，

各投稿のすぐ左の '.' (各投稿の左についた '.' のうち，もっとも右のもの) を '+' (半角プラス)，

同じ投稿に対する直接の返信について，それぞれのすぐ左にある '+' の間に位置する '.' を '|' (半角縦線)，

それ以外の '.' は ' ' (半角スペース)

に置き換えて欲しい．

上の簡易フォーマット表示に対する整形済みの表示は次のようになる．

hoge
+fuga
|+foobar
|+jagjag
| +zigzag
+piyo

Input

入力は複数のデータセットから構成される．各データセットの形式は次の通りである．

$n$
$s_1$
$s_2$
...
$s_n$

$n$ は簡易フォーマット表示の行数を表す整数であり，$1$ 以上 $1{,}000$ 以下と仮定してよい．
続く $n$ 行にはスレッドツリーの簡易フォーマット表示が記載されている．
$s_i$ は簡易フォーマット表示の $i$ 行目を表し，いくつかの '.' と，それに続く $1$ 文字以上 $50$ 文字以下のアルファベット小文字で構成された文字列からなる．
$s_1$ はスレッドの最初の投稿であり，'.' を含まない．
$s_2$, ..., $s_n$ はそのスレッドでの返信であり，必ず1つ以上の '.' を含む．

$n=0$ は入力の終わりを示す．これはデータセットには含めない．

Output

各データセットに対する整形済みの表示を各 $n$ 行で出力せよ．

Sample Input

6
hoge
.fuga
..foobar
..jagjag
...zigzag
.piyo
8
jagjag
.hogehoge
..fugafuga
...ponyoponyo
....evaeva
....pokemon
...nowawa
.buhihi
8
hello
.goodmorning
..howareyou
.goodafternoon
..letshavealunch
.goodevening
.goodnight
..gotobed
3
caution
.themessagelengthislessthanorequaltofifty
..sothelengthoftheentirelinecanexceedfiftycharacters
0

Output for Sample Input

hoge
+fuga
|+foobar
|+jagjag
| +zigzag
+piyo
jagjag
+hogehoge
|+fugafuga
| +ponyoponyo
| |+evaeva
| |+pokemon
| +nowawa
+buhihi
hello
+goodmorning
|+howareyou
+goodafternoon
|+letshavealunch
+goodevening
+goodnight
+gotobed
caution
+themessagelengthislessthanorequaltofifty
+sothelengthoftheentirelinecanexceedfiftycharacters


import java.util.ArrayList;
import java.util.Scanner;

public class Main {

	static int[][] map;
	static int[][] directions8 = { { -1, -1 }, { -1, 0 }, { -1, 1 }, { 0, -1 }, { 0, 1 }, { 1, -1 }, { 1, 0 },
			{ 1, 1 } };
	static int[][] directions4 = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
	static double ans;

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		while (true) {

			int D = sc.nextInt();
			int E = sc.nextInt();

			if ((D | E) == 0) {
				break;
			}

			int tmpX = 0;
			int tmpY = D;

			ans = Double.MAX_VALUE;

			for (int j = 0; j <= D; j++) {
				tmpX = j;
				tmpY = D - j;
				double tmpAns = Math.sqrt(tmpX * tmpX + tmpY * tmpY) - E;
				tmpAns = Math.abs(tmpAns);
				ans = Double.min(ans, tmpAns);
			}
			System.out.println(ans);
		}
	}

	// 素数判定
	static boolean isPrime(long n) {
		if (n == 2)
			return true;
		if (n < 2 || n % 2 == 0)
			return false;

		int i = 3;
		while (i <= Math.sqrt(n)) {
			if (n % i == 0)
				return false;
			else
				i += 2;
		}
		return true;
	}

	// BFS用に二つの配列を足し算する
	static int[] addArrayElms(int[] a, int[] b) {
		int[] c = new int[a.length];
		for (int i = 0; i < a.length; i++) {
			c[i] = a[i] + b[i];
		}
		return c;
	}

	// //二分探索
	// k <= num となる最小の配列要素kのインデックスを返す
	static private int binarySearch(long num, long[] orderedArray) {
		int lowerBorder = -1;
		int upperBorder = orderedArray.length;
		int mid;

		while (upperBorder - lowerBorder > 1) {
			mid = (upperBorder + lowerBorder) / 2;
			if (orderedArray[mid] <= num) {
				lowerBorder = mid;
			} else {
				upperBorder = mid;
			}
		}
		return lowerBorder;
	}

	// 二分探索
	// k <= num となる最小のList要素kのインデックスを返す
	static private int binarySearch(long num, ArrayList<Long> orderedList) {
		int lowerBorder = -1;
		int upperBorder = orderedList.size();
		int mid;

		while (upperBorder - lowerBorder > 1) {
			mid = (upperBorder + lowerBorder) / 2;
			if (orderedList.get(mid) <= num) {
				lowerBorder = mid;
			} else {
				upperBorder = mid;
			}
		}
		return lowerBorder;
	}

	// aとbの最小公倍数を求める
	public static int gcd(int a, int b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	public static long gcd(long a, long b) {
		return b == 0 ? a : gcd(b, a % b);
	}
}

MathJax.Hub.Config({
tex2jax: {inlineMath: [['$','$'], ['\\(','\\)']]}
});

Koto Municipal Subway

Koto市営地下鉄

Koto市は，下図のように，道路が碁盤の目状である有名な街である．
南北に伸びる道と東西に伸びる道は，それぞれ1kmの間隔で並んでいる．
Koto市の最も南西の交差点にあるKoto駅を (0, 0) として，そこから東に x km，北に y km 進んだ位置を (x, y) と記すこととする (0 ≤ x, y である)．

5年後に開かれるオリンピックにより観光客が増大することを見越して，市はKoto駅を始発駅とする新しい地下鉄の路線を建設することを決めた．
現在，Koto駅の次の駅として新しく建設されるShin-Koto駅までのレールを敷く計画を立てている．
レールは，Koto駅からShin-Koto駅に向かってまっすぐ敷く．
従って，Shin-Koto駅の場所を (x, y) としたとき，レールの長さは， √(x2 + y2) である．
レールを敷くための費用は，敷いたレールの長さ分だけ必要になる．
レールの長さが1.5kmのように小数であっても，費用も同じように1.5必要となる．

Shin-Koto駅の場所 (x, y) はまだ決定しておらず，以下の条件を満たす場所にする予定である．

交差点である．つまり， x と y がそれぞれ整数である．

Koto駅から道路に沿って歩いた最短距離が，ちょうど D である．つまり， x + y = D を満たす．

上の2つの条件を満たす中で，市が定めるレールの予算 E とレールの費用とのずれ | √(x2 + y2) - E | が最小となるようにShin-Koto駅の場所を選ぶ．
ここで |A| は， A の絶対値を表す．
あなたの仕事は，上記のようにShin-Koto駅を建設したときの，レールを敷くための費用と予算とのずれを出力するプログラムを作成することである．

Input

入力は，複数のデータセットから構成され，1つの入力に含まれるデータセットの数は100以下である． 各データセットの形式は次の通りである．

D E

D (1 ≤ D ≤ 100)は，Koto駅からShin-Koto駅まで道路に沿って歩いたときの最短距離を表す整数である．
E (1 ≤ E ≤ 100)は，レール建設のための予算を表す整数である．

入力の終わりは，空白で区切られた2つのゼロからなる行によって示される．

Output

各データセットに対して，問題の条件を満たすようにレールを敷いたときの費用と予算とのずれを1行で出力せよ．
答えには 10-3 を越える絶対誤差があってはならない．
各行の終わりに改行を出力しなかった場合や，不必要な文字を出力した場合，誤答と判断されてしまうため，注意すること．

Sample Input

2 1
7 5
7 6
7 7
76 5
8 41
0 0

Output for Sample Input

0.4142135624
0
0.0827625303
0
48.7401153702
33

Hint

1つ目のデータセットでは，下図のように，Koto駅から道路に沿って2km進んだ交差点がShin-Koto駅を建設する場所の候補となる．

各交差点にShin-Koto駅を建設した場合の，レールを敷くための費用と予算1とのずれは次のようになる．

(2, 0) ： | √(22 + 02) - 1 | = 1.0

(1, 1) ： | √(12 + 12) - 1 | = 0.4142135623...

(0, 2) ： | √(02 + 22) - 1 | = 1.0

よって，費用と予算とのずれが最小になるのは， (1, 1) に建設した場合となる．


import java.util.Scanner;
public class Main {

	public static void main(String[] args) {
		try(Scanner sc = new Scanner(System.in)) {
			int N = sc.nextInt();
			int count = 0;
			for(int i=0; i<N; i++) {
				String str = sc.next();
				if(str.equals("A")) {
					count++;
				} else {
					count--;
					if(count < 0) {
						System.out.println("NO");
						return;
					}
				}
			}
			if(count != 0) System.out.println("NO");
			else System.out.println("YES");
		}
	}
}

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

A - 阿吽の呼吸

Problem Statement

時は進んで 2060 年，共に 70 歳を迎える前田さんと後藤さんは長い付き合いの友人であり，大学時代にACM-ICPCで共に戦った仲間でもある．

二人は今でもよく一緒にお茶を飲みつつ，競技プログラミングの話で盛り上がっている．

二人で一緒にお茶を飲む時，前田さんが 1 回Aと言うと，その発言の後に後藤さんがちょうど 1 回Unと返事をする習慣がいつのまにか出来た．

しかし最近後藤さんは物忘れや勘違いをすることが多く，前田さんがAと言っても，後藤さんはたまにUnの返事を忘れたり，余計に返事をしたりする．

ついこの間も前田さんと後藤さんはお茶を飲みながら，二人のお気に入りのデータ構造について話し込んでいたようだ．

この時の会話の中から，Aで表される前田さんの発言と，Unで表される後藤さんの返事のみからなる記録が時系列で与えられたとき，後藤さんが習慣通りに反応したとみなすことが出来るかチェックしてほしい．

注意点として，前田さんの発言に対し，後藤さんの返事が多少遅れても，後藤さんは習慣通りに反応したとみなせる場合がある，ということが挙げられる．
例えば，前田さんが2回連続してAと言った後，後藤さんが 2 回連続してUnと返事をして会話が終了した場合は，後藤さんが習慣通りの返事をしたとみなされる (Sample Input 2 参照)．

また，会話が終了した時点で，前田さんがAと言った回数と，後藤さんがUnと返事した回数が一致しても，後藤さんが習慣通りに返事をしたとはみなされない場合もあるので注意すること．
例えば，前田さんが1回Aと言った後，後藤さんが 2 回連続してUnと返事し，その後で前田さんが 1 回Aと言って会話が終了した場合は，後藤さんが習慣通りの返事をしたとはみなされない (Sample Input 3 参照)．

Input

入力は以下の形式で与えられる．

$N$

$S_1$

$S_2$

$…$

$S_N$

最初の行はひとつの整数からなる．
$N$ は，記録に含まれる前田さんがAと発言した回数と後藤さんがUnと返事した回数の合計を表し，$1 \leq N \leq 100$ を満たす．
その後 $N$ 行に，文字列 $S_i$ が続き，各 $S_i (1 \leq i \leq N)$ はAかUnのどちらかに一致する．ここでAは前田さんの発言，Unは後藤さんの返事を表す．
$i$ の小さい順に $S_i$ が記録されたものとする．
前田さんと後藤さんが同時に発言することは無かったとする．

Output

後藤さんが習慣通りに反応したとみなすことが出来ればYES，出来なければNOを1行で出力すること．

Sample Input 1

4
A
Un
A
Un

Output for the Sample Input 1

YES

Sample Input 2

4
A
A
Un
Un

Output for the Sample Input 2

YES

Sample Input 3

4
A
Un
Un
A

Output for the Sample Input 3

NO

Sample Input 4

1
Un

Output for the Sample Input 4

NO


import java.util.*;

public class Main {
	static final long MODULO = 1_000_000_000 + 7;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int K = sc.nextInt();
		int C = sc.nextInt() - 1;
		int T = sc.nextInt();
		int[] a = new int[K];
		int[] b = new int[K];
		int[] t = new int[K];
		for (int i = 0; i < K; ++i) {
			a[i] = sc.nextInt();
			b[i] = sc.nextInt();
			t[i] = sc.nextInt();
		}
		// dp[t]=A[1]dp[t-1]+A[2]dp[t-2]+A[3]dp[t-3]
		long[][][] A = new long[6][N][N];
		for (int i = 0; i < K; ++i) {
			for (int j = 0; j < b[i]; ++j) {
				A[t[i]][j][(a[i] - 1) + j] += 1;
			}
			for (int j = 0; j < a[i] - 1; ++j) {
				A[t[i]][b[i] + j][j] += 1;
			}
			for (int j = a[i] + b[i] - 1; j < N; ++j) {
				A[t[i]][j][j] += 1;
			}
		}
		long[][] dp = new long[6][N];
		dp[0][C] = 1;
		for (int i = 1; i <= 5; ++i) {
			for (int j = 0; j < i; ++j) {
				dp[i] = addVec(dp[i], mulVec(A[i - j], dp[j]));
			}
		}
		long[] v = new long[N * 5];
		for (int i = 0; i < 5; ++i) {
			for (int j = 0; j < N; ++j) {
				v[j + i * N] = dp[i][j];
			}
		}
		long[][] mx = new long[5 * N][5 * N];
		for (int i = N; i < 5 * N; ++i) {
			mx[i - N][i] = 1;
		}
		for (int i = 1; i <= 5; ++i) {
			for (int j = 0; j < N; ++j) {
				for (int k = 0; k < N; ++k) {
					mx[4 * N + j][N * (5 - i) + k] = A[i][j][k];
				}
			}
		}

		v = mulVec(pow(mx, T), v);
		System.out.println(v[0]);
	}

	static long[][] mul(long[][] a, long[][] b) {
		int n = a.length;
		long[][] ret = new long[n][n];
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				for (int k = 0; k < n; ++k) {
					ret[i][j] += a[i][k] * b[k][j] % MODULO;
					ret[i][j] %= MODULO;
				}
			}
		}
		return ret;
	}

	static long[] mulVec(long[][] a, long[] v) {
		int n = v.length;
		long[] ret = new long[n];
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				ret[i] += a[i][j] * v[j] % MODULO;
				ret[i] %= MODULO;
			}
		}
		return ret;
	}

	static long[] addVec(long[] a, long[] b) {
		int n = a.length;
		long[] ret = new long[n];
		for (int i = 0; i < n; ++i) {
			ret[i] = (a[i] + b[i]) % MODULO;
		}
		return ret;
	}

	static long[][] pow(long[][] a, long n) {
		int len = a.length;
		long[][] ret = new long[len][len];
		for (int i = 0; i < len; ++i)
			ret[i][i] = 1;
		for (; n > 0; n >>= 1, a = mul(a, a)) {
			if (n % 2 == 1) {
				ret = mul(ret, a);
			}
		}
		return ret;
	}

	static void showMatrix(long[][] a) {
		int n = a.length;
		for (int i = 0; i < n; ++i) {
			for (int j = 0; j < n; ++j) {
				System.out.print(a[i][j] + " ");
			}
			System.out.println();
		}
	}

	static void showVec(long[] a) {
		for (int i = 0; i < a.length; ++i) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}

	static void tr(Object... objects) {
		System.out.println(Arrays.deepToString(objects));
	}
}

G: 運命力 - Destiny Draw -

問題

Mr. D はカードゲームで勝負をすることになった。
このカードゲームでは、 N 枚のカードの山を用いる。
また、山のカードには、上から順に 1, 2, 3, ... , N の番号がついている。

D で始まるものすべてを背負う彼に敗北は許されないが、不幸にも Mr. D はカードゲームが不得手である。
そこで、自分が引くカードをコントロールすることで勝利を手にすることにした。

Mr. D は K 種類のシャッフルが可能である。
K 種類のうち i 番目のシャッフルでは上から a_i 枚目から a_i+b_i − 1枚目までのちょうど b_i 枚を引き抜き、上に重ねる。
i番目のシャッフルを1 回するとき、それぞれ t_i 秒を要する。

ちょうど T 秒のシャッフルの後、一番上のカードを C にする方法は何通りあるか。 数が多くなる可能性があるので、 10^9+7 で割った余りを出力せよ。

入力形式

入力は次の形式で与えられる。

N K C T
a_1 b_1 t_1
a_2 b_2 t_2
...
a_K b_K t_K

N は整数で 2 \≤ N \≤ 40 を満たす。

K は整数で 1 \≤ K \≤ \frac{N (N+1)}{2} を満たす

C は整数で 1 \≤ C \≤ N を満たす

T は整数で 1 \≤ T \≤ 1,000,000 を満たす

a_i (i = 1, 2, ... , K) は整数で 1 \≤ a_i \≤ N を満たす

b_i (i = 1, 2, ... , K) は整数で 1 \≤ b_i \≤ N − a_i + 1 を満たす

a_i = a_j かつ b_i = b_j を満たすとき i = j に限定される

t_i は整数で 1 \≤ t_i \≤ 5 を満たす

出力形式

答えを 10^9+7 で割った余りを一行で出力せよ。

入力例1

4 1 1 6
3 2 3

出力例1

1

入力例2

4 1 1 5
3 2 3

出力例2

0

入力例3

6 2 2 5
1 2 1
2 5 3

出力例3

3

ちょうど 5 秒で一番上のカードを 2 にする方法は以下の 3 通りである。

1→1→2
1→2→1
2→1→1

入力例4

6 8 3 10
1 4 5
1 3 3
1 6 5
1 2 2
1 1 4
2 5 1
4 3 1
2 1 3

出力例4

3087


import java.util.Scanner;

public class Main {
	int n, deep;
	int[] d, f;
	boolean[][] g;
	void run() {
		Scanner scan = new Scanner(System.in);
		n = scan.nextInt();
		g = new boolean[n][n];
		for (int i = 0; i < n; i++) {
			int u = scan.nextInt();
			int k = scan.nextInt();
			for (int j = 0; j < k; j++) {
				int v = scan.nextInt();
				g[u - 1][v - 1] = true;
			}
		}
		deep = 0;
		d = new int[n];
		f = new int[n];
		dfs(0);
		for (int i = 0; i < n; i++)
			System.out.println((i + 1) + " " + d[i] + " " + f[i]);
	}
	void dfs(int u) {
		if (f[u] > 0)
			return;

		d[u] = ++deep;
		for (int i = 0; i < n; i++)
			if (g[u][i])
				dfs(i);
		f[u] = ++deep;
	}
	public static void main(String[] args) {
		new Main().run();
	}
}

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Depth First Search

Depth-first search (DFS) follows the strategy to search ”deeper” in the graph whenever possible. In DFS, edges are recursively explored out of the most recently discovered vertex $v$ that still has unexplored edges leaving it. When all of $v$'s edges have been explored, the search ”backtracks” to explore edges leaving the vertex from which $v$ was discovered.

This process continues until all the vertices that are reachable from the original source vertex have been discovered. If any undiscovered vertices remain, then one of them is selected as a new source and the search is repeated from that source.

DFS timestamps each vertex as follows:

$d[v]$ records when $v$ is first discovered.

$f[v]$ records when the search finishes examining $v$’s adjacency list.

Write a program which reads a directed graph $G = (V, E)$ and demonstrates DFS on the graph based on the following rules:

$G$ is given in an adjacency-list. Vertices are identified by IDs $1, 2,... n$ respectively.

IDs in the adjacency list are arranged in ascending order.

The program should report the discover time and the finish time for each vertex.

When there are several candidates to visit during DFS, the algorithm should select the vertex with the smallest ID.

The timestamp starts with 1.

Input

In the first line, an integer $n$ denoting the number of vertices of $G$ is given. In the next $n$ lines, adjacency lists of $u$ are given in the following format:

$u$ $k$ $v_1$ $v_2$ ... $v_k$

$u$ is ID of the vertex and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.

Output

For each vertex, print $id$, $d$ and $f$ separated by a space character in a line. $id$ is ID of the vertex, $d$ and $f$ is the discover time and the finish time respectively. Print in order of vertex IDs.

Constraints

$1 \leq n \leq 100$

Sample Input 1

4
1 1 2
2 1 4
3 0
4 1 3

Sample Output 1

1 1 8
2 2 7
3 4 5
4 3 6

Sample Input 2

6
1 2 2 3
2 2 3 4
3 1 5
4 1 6
5 1 6
6 0

Sample Output 2

1 1 12
2 2 11
3 3 8
4 9 10
5 4 7
6 5 6

This is example for Sample Input 2 (discover/finish)

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.


import java.util.LinkedList;
import java.util.Scanner;
import java.util.Iterator;

class Graph {
	private int totalVertex;
	//adjMatrix[u][v] = 1 if there is an edge from u to v, otherwise 0
	private int[][] adjMatrix;
	//adjWeight[u][v] -- the weight of the edge from u to v if there is one
	private int[][] adjWeight;
	//if a node is settled (e.g., processed in the Dijkstra's algorithm)
	private Boolean[] ifSettled;
	public Graph() { totalVertex = 0; }
	public int getTotalVertex() { return totalVertex; }
	//load graph from standard input
	public void loadAdjMatrix() {
		Scanner in = new Scanner(System.in);
		totalVertex = in.nextInt();
		adjMatrix = new int[totalVertex][totalVertex];
		adjWeight = new int[totalVertex][totalVertex];
		ifSettled = new Boolean[totalVertex];
		int i, j;
		for(i = 0; i < totalVertex; i ++) {
			ifSettled[i] = false;
			for(j = 0; j < totalVertex; j ++) {
				adjMatrix[i][j] = adjWeight[i][j] = 0;
			}
		}
		int u, v;
		for(i = 0; i < totalVertex; i ++) {
			u = in.nextInt();
			int degree = in.nextInt();
			for(j = 0; j < degree; j ++) {
				v = in.nextInt();
				adjMatrix[u][v] = 1;
				adjWeight[u][v] = in.nextInt();
			}
		}
		in.close();
	}
	//return weight of the edge from u to v if there is one
	public int getWeight(int u, int v) {
		return adjWeight[u][v];
	}
	//return neighbors of u as a LinkedList
	public LinkedList<Integer> getNeighbors(int u) {
		LinkedList<Integer> tmp = new LinkedList<Integer>();
		for(int v = 0; v < totalVertex; v ++) {
			if(adjMatrix[u][v] == 1) tmp.add(v);
		}
		return tmp;
	}
	//return unsettled neighbors of u as a LinkedList
	public LinkedList<Integer> getUnsettledNeighbors(int u) {
		LinkedList<Integer> tmp = new LinkedList<Integer>();
		for(int v = 0; v < totalVertex; v ++) {
			if((adjMatrix[u][v] == 1) && (ifSettled[v] == false)) tmp.add(v);
		}
		return tmp;
	}
	//return the unsettled node that has the smallest dist
	public int getUnsettledNearest(int[] dist) {
		int md = Integer.MAX_VALUE;
		int mv = -1;
		int v;
		for(v = 0; v < totalVertex; v ++) {
			if((ifSettled[v] == false) && (dist[v] < md)) {
				md = dist[v];
				mv = v;
			}
		}
		return mv;
	}
	//implement the following
	public int[] Dijkstra(int s) {
		int [] D = new int[totalVertex];
		for(int i=0; i<totalVertex; i++){
			D[i] = Integer.MAX_VALUE;
		}
		D[s] = 0;
		for(int i=0; i<totalVertex; i++){
			ifSettled[s] = true;
//			if(D[s] == Integer.MAX_VALUE) return void; // unreachable
			LinkedList<Integer> UnsettleNeighbors = getUnsettledNeighbors(s);
			Iterator<Integer> it = UnsettleNeighbors.iterator();
			while(it.hasNext()){
				int v = it.next();
				if(D[v] > (D[s] + adjWeight[s][v]))
					D[v] = D[s] + adjWeight[s][v];
			}
			s = getUnsettledNearest(D);
		}
		return D;
	}
}

public class Main {
	public static void main(String[] argv) {
		Graph g = new Graph();
		g.loadAdjMatrix();
		int[] dist = g.Dijkstra(0);
		for(int i = 0; i < g.getTotalVertex(); i ++) {
			System.out.println(i + " " + dist[i]);
		}
	}
}

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Single Source Shortest Path

For a given weighted graph $G = (V, E)$, find the shortest path from a source to each vertex. For each vertex $u$, print the total weight of edges on the shortest path from vertex $0$ to $u$.

Input

In the first line, an integer $n$ denoting the number of vertices in $G$ is given. In the following $n$ lines, adjacency lists for each vertex $u$ are respectively given in the following format:

$u$ $k$ $v_1$ $c_1$ $v_2$ $c_2$ ... $v_k$ $c_k$

Vertices in $G$ are named with IDs $0, 1, ..., n-1$. $u$ is ID of the target vertex and $k$ denotes its degree. $v_i (i = 1, 2, ... k)$ denote IDs of vertices adjacent to $u$ and $c_i$ denotes the weight of a directed edge connecting $u$ and $v_i$ (from $u$ to $v_i$).

Output

For each vertex, print its ID and the distance separated by a space character in a line respectively. Print in order of vertex IDs.

Constraints

$1 \leq n \leq 100$

$0 \leq c_i \leq 100,000$

$|E| \leq 10,000$

All vertices are reachable from vertex $0$

Sample Input 1

5
0 3 2 3 3 1 1 2
1 2 0 2 3 4
2 3 0 3 3 1 4 1
3 4 2 1 0 1 1 4 4 3
4 2 2 1 3 3

Sample Output 1

0 0
1 2
2 2
3 1
4 3

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.


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

public class Main {
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuffer sb = new StringBuffer();

		String str = br.readLine();
		int n = Integer.parseInt(br.readLine());

		for(int i = 0; i < n; i++){
			String temp = br.readLine();
			if(str.contains(temp)){
				sb.append("1" + "\n");
			} else {
				sb.append("0" + "\n");
			}
		}
		System.out.print(sb.toString());
	}
}

String Search

Determine whether a text T includes a pattern P. Your program should answer for given queries consisting of P_i.

Input

In the first line, a text T is given. In the second line, an integer Q denoting the number of queries is given. In the following Q lines, the patterns P_i are given respectively.

Output

For each question, print 1 if the text includes P_i, or print 0 otherwise.

Constraints

1 ≤ length of T ≤ 1000000

1 ≤ length of P_i ≤ 1000

1 ≤ Q ≤ 10000

The input consists of alphabetical characters and digits

Sample Input 1

aabaaa
4
aa
ba
bb
xyz

Sample Output 1

1
1
0
0


import java.util.*;

class Main{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int a[],n;
        n = sc.nextInt();
        a = new int[n];
        for(int i=0;i<n;i++){
            a[i]=sc.nextInt();
        }
        for(int i=1;i<n;i++){
            int j=i;
            print(a);
            while(j>0){
                if(a[j-1]>a[j]){
                    int k = a[j-1];
                    a[j-1] = a[j];
                    a[j] = k;
                    j--;
                }else{
                    break;
                }
            }
        }
        print(a);
    }

    public static void print(int a[]){
        int n=a.length;
        System.out.print(a[0]);
        for(int i=1;i<n;i++){
            System.out.print(" "+a[i]);
        }
        System.out.println("");
    }
}

Insertion Sort

Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:

for i = 1 to A.length-1
key = A[i]
/* insert A[i] into the sorted sequence A[0,...,j-1] */
j = i - 1
while j >= 0 and A[j] > key
A[j+1] = A[j]
j--
A[j+1] = key

Note that, indices for array elements are based on 0-origin.

To illustrate the algorithms, your program should trace intermediate result for each step.

Input

The first line of the input includes an integer N, the number of elements in the sequence.

In the second line, N elements of the sequence are given separated by a single space.

Output

The output consists of N lines. Please output the intermediate sequence in a line for each step. Elements of the sequence should be separated by single space.

Constraints

1 ≤ N ≤ 100

Sample Input 1

6
5 2 4 6 1 3

Sample Output 1

5 2 4 6 1 3
2 5 4 6 1 3
2 4 5 6 1 3
2 4 5 6 1 3
1 2 4 5 6 3
1 2 3 4 5 6

Sample Input 2

3
1 2 3

Sample Output 2

1 2 3
1 2 3
1 2 3

Hint

Template in C


import java.util.InputMismatchException;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		try {
			int n = sc.nextInt();

			int[] a = new int[n];

			for(int i = 0; i < a.length; i++) {
				a[i] = sc.nextInt();
			}

			disp(a);
			insertionSort(a);
		} catch(InputMismatchException ex) {
			ex.printStackTrace();
		} finally {
			sc.close();
		}
	}

	private static void insertionSort(int[] a) {
		for(int i = 1; i < a.length; i++) {
			int v = a[i];
			int j = i - 1;

			while(j >= 0 && a[j] > v) {
				a[j + 1] = a[j];

				j--;
			}

			a[j + 1] = v;

			disp(a);
		}
	}

	private static void disp(int[] a) {
		for(int i = 0; i < a.length - 1; i++) {
			System.out.print(a[i] + " ");
		}

		System.out.println(a[a.length - 1]);
	}
}


import java.util.Scanner;

public class Main
{

 public static void main(String args[])
 {
  int N=0;
  Scanner s = new Scanner(System.in);
  N = s.nextInt();
  int[] number = new int[N];
  Scanner sc = new Scanner(System.in);
  for(int i=0;i<N;i++)
  {
   number[i]=s.nextInt();
  }
  sc.close();
  for(int k=0;k<N;k++)
  {
	  System.out.print(number[k]);
	  if(k!=N-1)System.out.print(" ");
  }
  System.out.print("\n");
  for(int i=1;i<N;i++)
  {
   int t=number[i];
   int j=0;
   for(j=i-1;j>=0;j--)
   {
    number[j+1]=number[j];
    if(t>number[j])break;
   }
   number[j+1]=t;
   for(int k=0;k<N;k++)
   {
 	  System.out.print(number[k]);
 	  if(k!=N-1)System.out.print(" ");
   }
   System.out.print("\n");
  }
 }
}


import java.io.*;
import java.util.*;

public class Main{
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;

        str = br.readLine();
        int x = Integer.parseInt(str.trim());

        int ans = 0;
        for(int i = 0;i < x ;i++){
            str = br.readLine();
            int temp = Integer.parseInt(str.trim());
            int count = 0;
            for(int j = 1; j <= temp ;j++){
                int m = temp % j;
                if(m == 0){
                    count++;
                }
            }
            if(count ==2){
                ans++;
                //System.out.println(temp);
            }
        }

        System.out.println(ans);

        br.close();
    }

}

Prime Numbers

A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.

Write a program which reads a list of N integers and prints the number of prime numbers in the list.

Input

The first line contains an integer N, the number of elements in the list.

N numbers are given in the following lines.

Output

Print the number of prime numbers in the given list.

Constraints

1 ≤ N ≤ 10000

2 ≤ an element of the list ≤ 108

Sample Input 1

5
2
3
4
5
6

Sample Output 1

3

Sample Input 2

11
7
8
9
10
11
12
13
14
15
16
17

Sample Output 2

4


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

class Main {
	private static Scanner scanner;
	public static void main(String[] args) {
		int answer = 0;
		int count = 0;
		boolean flag = false;
		List<Integer> list = new ArrayList<Integer>();
		scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		for(int i=0; i<n; i++){
			list.add(scanner.nextInt());
		}
		List<Integer> distinctList = distinct(list);
		Collections.sort(distinctList);
		if(distinctList.size() > 100)count = 100;
		for(int i=0; i<distinctList.size(); i++){
			int maxIndex = list.lastIndexOf(distinctList.get(distinctList.size() - (i + 1)));
			List<Integer> tmpList = list.subList(0, maxIndex);
			if((!tmpList.isEmpty())){
				if(!flag){
					answer = distinctList.get(distinctList.size() - (i+1)) - Collections.min(tmpList);
					flag = true;
				}
				else if(answer < (distinctList.get(distinctList.size() - (i+1)) - Collections.min(tmpList))){
					answer = distinctList.get(distinctList.size() - (i+1)) - Collections.min(tmpList);
				}
			}
		}
		System.out.println(answer);
	}
	public static List<Integer> distinct(List<Integer> list){
		List<Integer> distictList = new ArrayList<Integer>();
		for(int i: list){
			if(!distictList.contains(i))distictList.add(i);
		}
		return distictList;
	}
}

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Maximum Profit

You can obtain profits from foreign exchange margin transactions. For example, if you buy 1000 dollar at a rate of 100 yen per dollar, and sell them at a rate of 108 yen per dollar, you can obtain (108 - 100) × 1000 = 8000 yen.

Write a program which reads values of a currency $R_t$ at a certain time $t$ ($t = 0, 1, 2, ... n-1$), and reports the maximum value of $R_j - R_i$ where $j > i$ .

Input

The first line contains an integer $n$. In the following $n$ lines, $R_t$ ($t = 0, 1, 2, ... n-1$) are given in order.

Output

Print the maximum value in a line.

Constraints

$2 \leq n \leq 200,000$

$1 \leq R_t \leq 10^9$

Sample Input 1

6
5
3
1
3
4
3

Sample Output 1

3

Sample Input 2

3
4
3
2

Sample Output 2

-1


import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        int ans = 0;
        for(int i = 0; i < n; i++){
            a[i] = sc.nextInt();
        }
        boolean flag = true;
        while(flag){
            flag = false;
            for(int j = n-1; j > 0; j--){
                if(a[j] < a[j-1]){
                    int work = a[j];
                    a[j] = a[j-1];
                    a[j-1] = work;
                    ans ++;
                    flag =true;
                }
            }
        }
        for(int i = 0; i < n-1; i++){
            System.out.print(a[i] + " ");
        }
        System.out.println(a[n-1]);
        System.out.println(ans);
    }
}

Bubble Sort

Write a program of the Bubble Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:

BubbleSort(A)
1 for i = 0 to A.length-1
2 for j = A.length-1 downto i+1
3 if A[j] < A[j-1]
4 swap A[j] and A[j-1]

Note that, indices for array elements are based on 0-origin.

Your program should also print the number of swap operations defined in line 4 of the pseudocode.

Input

The first line of the input includes an integer N, the number of elements in the sequence.

In the second line, N elements of the sequence are given separated by spaces characters.

Output

The output consists of 2 lines.

In the first line, please print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character.

In the second line, please print the number of swap operations.

Constraints

1 ≤ N ≤ 100

Sample Input 1

5
5 3 2 4 1

Sample Output 1

1 2 3 4 5
8

Sample Input 2

6
5 2 4 6 1 3

Sample Output 2

1 2 3 4 5 6
9


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

public class Main{
	static int N;
	static int [] A;
	static int max;
	static int count;
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		N = Integer.parseInt(br.readLine());
		String [] temp = br.readLine().split(" ");
		max = temp.length;
		A = new int[max];
		for(int i=0;i < max;i++){
			A[i] = Integer.parseInt(temp[i]);
		}

		for(int i=0;i < max;i++){
			sort();
		}

		for(int i=0;i < max-1;i++){
			System.out.print(A[i]+" ");
		}
		System.out.println(A[max-1]);
		System.out.print(count);
	}

	public static void sort(){
		for(int i=max-1;i>0;i--){
			if(A[i] >= A[i-1]){
				continue;
			}
			else{
				int num = A[i];
				A[i] = A[i-1];
				A[i-1] = num;
				count++;
			}

		}
	}

}


import java.util.Scanner;

/**
 *
 */

/**
 * @author kawakami
 *
 */
class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuilder sb = new StringBuilder();
		Scanner as = new Scanner(System.in);

		int N = 0;
		int tre = 0;
		int count = 0;
		int A[];

		Boolean flag = true;

		N = Integer.parseInt(as.next());

		A = new int[N];

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

			A[i] = Integer.parseInt(as.next());

		}

		while(flag){

			flag = false;
			for(int j=N-1;j>=1;j--){

				if(A[j] < A[j-1]){

					tre = A[j];
					A[j] = A[j-1];
					A[j-1] = tre;
					flag = true;
					count++;

				}

			}

		}

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

			if(i != N-1){

				sb.append(A[i]).append(' ');

			}
			else{

				sb.append(A[i]);

			}
		}
		System.out.println(sb.toString());
		sb.setLength(0);
		sb.append(count);
		System.out.println(sb.toString());

	}

}


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

public class Main {

	public static void printArray(String[] cardSort) {
		for (int i = 0; i < cardSort.length; i++) {
			System.out.print(cardSort[i]);

			if (i == cardSort.length - 1) {
				break;
			}
			System.out.print(" ");
		}
		System.out.println();
	}

	public static boolean isStable(String in[], String out[], int N) {

		for(int i = 0; i < N; i++) {
			for(int j = i + 1; j < N; j++) {
				for(int a = 0; a < N; a++) {
					for(int b = a + 1; b < N; b++) {
						if(in[i].charAt(1) == in[j].charAt(1) && in[i].equals(out[b]) && in[j].equals(out[a])) {
							return false;
						}
					}
				}
			}
		}
		return true;
	}

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int progCardNumOfSheets = Integer.parseInt(br.readLine());

		String[] card = br.readLine().split(" ");

		String[] cardNumBubbleSort = new String[progCardNumOfSheets];
		String[] cardNumSelectionSort = new String[progCardNumOfSheets];

		for(int i = 0; i < progCardNumOfSheets; i++) {
			cardNumBubbleSort[i] = card[i];
			cardNumSelectionSort[i] = card[i];
		}

		int compareNumResult = 0;
		String compareNum1 = "";
		String compareNum2 = "";

		boolean isSortFlag = true;

		while(isSortFlag) {
			isSortFlag = false;

			for(int i = progCardNumOfSheets - 1; i > 0; i-- ) {
				compareNum1 = cardNumBubbleSort[i].substring(1);
				compareNum2 = cardNumBubbleSort[i - 1].substring(1);
				compareNumResult = compareNum1.compareTo(compareNum2);
				if(compareNumResult < 0) {
					String tmp = cardNumBubbleSort[i - 1];
					cardNumBubbleSort[i - 1] = cardNumBubbleSort[i];
					cardNumBubbleSort[i] = tmp;
					isSortFlag = true;
				}
			}
		}

		printArray(cardNumBubbleSort);

		if(isStable(card, cardNumBubbleSort, progCardNumOfSheets)) {
			System.out.println("Stable");
		} else {
			System.out.println("Not stable");
		}

		int minNum = 0;
		for(int i = 0; i < progCardNumOfSheets; i++) {
			minNum = i;

			for(int j = i; j < progCardNumOfSheets; j++) {
				compareNum1 = cardNumSelectionSort[j].substring(1);
				compareNum2 = cardNumSelectionSort[minNum].substring(1);
				compareNumResult = compareNum1.compareTo(compareNum2);
				if(compareNumResult < 0) {
					minNum = j;
				}
			}
			if(i != minNum) {
				String tmp = cardNumSelectionSort[i];
				cardNumSelectionSort[i] = cardNumSelectionSort[minNum];
				cardNumSelectionSort[minNum] = tmp;
			}
		}

		printArray(cardNumSelectionSort);

		if(isStable(card, cardNumSelectionSort, progCardNumOfSheets)) {
			System.out.println("Stable");
		} else {
			System.out.println("Not stable");
		}
	}
}

Stable Sort

Let's arrange a deck of cards. There are totally 36 cards of 4 suits(S, H, C, D) and 9 values (1, 2, ... 9). For example, 'eight of heart' is represented by H8 and 'one of diamonds' is represented by D1.

Your task is to write a program which sorts a given set of cards in ascending order by their values using the Bubble Sort algorithms and the Selection Sort algorithm respectively. These algorithms should be based on the following pseudocode:

BubbleSort(C)
1 for i = 0 to C.length-1
2 for j = C.length-1 downto i+1
3 if C[j].value < C[j-1].value
4 swap C[j] and C[j-1]

SelectionSort(C)
1 for i = 0 to C.length-1
2 mini = i
3 for j = i to C.length-1
4 if C[j].value < C[mini].value
5 mini = j
6 swap C[i] and C[mini]

Note that, indices for array elements are based on 0-origin.

For each algorithm, report the stability of the output for the given input (instance). Here, 'stability of the output' means that: cards with the same value appear in the output in the same order as they do in the input (instance).

Input

The first line contains an integer N, the number of cards.

N cards are given in the following line. Each card is represented by two characters. Two consecutive cards are separated by a space character.

Output

In the first line, print the arranged cards provided by the Bubble Sort algorithm. Two consecutive cards should be separated by a space character.

In the second line, print the stability ("Stable" or "Not stable") of this output.

In the third line, print the arranged cards provided by the Selection Sort algorithm. Two consecutive cards should be separated by a space character.

In the fourth line, print the stability ("Stable" or "Not stable") of this output.

Constraints

1 ≤ N ≤ 36

Sample Input 1

5
H4 C9 S4 D2 C3

Sample Output 1

D2 C3 H4 S4 C9
Stable
D2 C3 S4 H4 C9
Not stable

Sample Input 2

2
S1 H1

Sample Output 2

S1 H1
Stable
S1 H1
Stable


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

public class Main{
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] str = br.readLine().split(" ");
		int n = Integer.parseInt(str[0]);
		int q = Integer.parseInt(str[1]);
		int[] data = new int[n];
		String[] sdata = new String[n];
		int counter = 0;
		int sum = 0;
		for(int i = 0 ; i < n ; i ++){
			str = br.readLine().split(" ");
			sdata[i] = str[0];
			data[i] = Integer.parseInt(str[1]);
			sum+=data[i];
		}
		for(int i = 0 ; i <= n ; i ++){
			if(i==n)
				i=0;
			if(data[i]==0){
				continue;
			}
			else if(data[i]!=0 && data[i]>q){
				counter+=q;
				data[i]-=q;
				continue;
			}
			else if(data[i]!=0 && data[i]<=q){
				counter+=data[i];
				System.out.println(sdata[i]+" "+counter);
				data[i]=0;
				continue;
			}
			if(counter == sum)
				System.exit(0);
		}
	}
}

There are n processes in a queue. Each process has namei and timei. The round-robin scheduling handles the processes in order. A round-robin scheduler gives each process a quantum (a time slot) and interrupts the process if it is not completed by then. The process is resumed and moved to the end of the queue, then the scheduler handles the next process in the queue.

For example, we have the following queue with the quantum of 100ms.

A(150) - B(80) - C(200) - D(200)

First, process A is handled for 100ms, then the process is moved to the end of the queue with the remaining time (50ms).

B(80) - C(200) - D(200) - A(50)

Next, process B is handled for 80ms. The process is completed with the time stamp of 180ms and removed from the queue.

C(200) - D(200) - A(50)

Your task is to write a program which simulates the round-robin scheduling.

Input

n q

name1 time1

name2 time2

...

namen timen

In the first line the number of processes n and the quantum q are given separated by a single space.

In the following n lines, names and times for the n processes are given. namei and timei are separated by a single space.

Output

For each process, prints its name and the time the process finished in order.

Constraints

1 ≤ n ≤ 100000

1 ≤ q ≤ 1000

1 ≤ timei ≤ 50000

1 ≤ length of namei ≤ 10

1 ≤ Sum of timei ≤ 1000000

Sample Input 1

5 100
p1 150
p2 80
p3 200
p4 350
p5 20

Sample Output 1

p2 180
p5 400
p1 450
p3 550
p4 800

Notes

Template in C


import java.util.*;
public class Main {
	Scanner sc = new Scanner(System.in);
	Deque<Integer> List = new ArrayDeque<Integer>();
	int n;
	String order;
	int data;
	int ans;
	public void input() {
		n = sc.nextInt();
		for(int i=0; i<n; i++) {
			order = sc.next();
			if( order.equals("insert") ) {
				data = sc.nextInt();
				List.addFirst(data);
			}else if( order.equals("delete") ) {
				data = sc.nextInt();
				List.remove(data);
			}
			else if( order.equals("deleteFirst") ) {List.removeFirst();}
			else{List.removeLast();}
		}
	}
	public void output() {
		while(List.size() != 0) {
			ans = List.poll();
			if(List.size() == 0) System.out.print(ans+" \n");
			else System.out.print(ans+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {
		Main obj = new Main();
		obj.input();
		obj.output();
	}
}

Doubly Linked List

Your task is to implement a double linked list.

Write a program which performs the following operations:

insert x: insert an element with key x into the front of the list.

delete x: delete the first element which has the key of x from the list. If there is not such element, you need not do anything.

deleteFirst: delete the first element from the list.

deleteLast: delete the last element from the list.

Input

The input is given in the following format:

n

command1

command2

...

commandn

In the first line, the number of operations n is given. In the following n lines, the above mentioned operations are given in the following format:

insert x

delete x

deleteFirst

deleteLast

Output

Print all the element (key) in the list after the given operations. Two consequtive keys should be separated by a single space.

Constraints

The number of operations ≤ 2,000,000

The number of delete operations ≤ 20

0 ≤ value of a key ≤ 109

The number of elements in the list does not exceed 106

For a delete, deleteFirst or deleteLast operation, there is at least one element in the list.

Sample Input 1

7
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5

Sample Output 1

6 1 2

Sample Input 2

9
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5
deleteFirst
deleteLast

Sample Output 2

1


import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static ArrayList<Integer> list = new ArrayList<Integer>();

    public static void main(String[] args) {
        int total;

        Scanner inp = new Scanner(System.in);
        total = inp.nextInt();

        for (int k = 0; k < total; k++) {
            String command = inp.next();

            switch (command) {
                case "insert": {
                    int num = inp.nextInt();

                    insert_x(num);
                    break;
                }
                case "delete": {
                    int num = inp.nextInt();

                    delete_x(num);
                    break;
                }
                case "deleteFirst":
                    deleteFirst();
                    break;
                case "deleteLast":
                    deleteLast();
                    break;
            }
        }

        for (int l = 0; l < list.size(); l++) {
            System.out.printf(" %d", list.get(l));

        }
    }

    public static void insert_x(int num) {
        list.add(0, num);
    }

    public static void delete_x(int num) {
        list.remove(list.indexOf(num));
    }

    public static void deleteFirst() {
        list.remove(0);
    }

    public static void deleteLast() {
        list.remove(list.size()-1);
    }
}