Problem:
Score : 300 points

Problem Statement

You are given a sequence of length N: A_1, A_2, ..., A_N.
For each integer i between 1 and N (inclusive), answer the following question:

Find the maximum value among the N-1 elements other than A_i in the sequence.

Constraints

2 \leq N \leq 200000

1 \leq A_i \leq 200000

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1
:
A_N

Output

Print N lines. The i-th line (1 \leq i \leq N) should contain the maximum value among the N-1 elements other than A_i in the sequence.

Sample Input 1

3
1
4
3

Sample Output 1

4
3
4

The maximum value among the two elements other than A_1, that is, A_2 = 4 and A_3 = 3, is 4.

The maximum value among the two elements other than A_2, that is, A_1 = 1 and A_3 = 3, is 3.

The maximum value among the two elements other than A_3, that is, A_1 = 1 and A_2 = 4, is 4.

Sample Input 2

2
5
5

Sample Output 2

5
5

Solution in Rust (1.15.1) (judge verdict: Accepted)

#![allow(unused_variables)]
#![allow(unused_imports)]
#![allow(dead_code)]
use std::io;
use std::str::FromStr;
use std::iter::FromIterator;
use std::cmp::{max, min, Ordering};
use std::collections::*;
use std::mem::{replace, swap};

// [NOTE] つかうときには trim() 入れないと RE になるので注意
// abcde
fn read_as_line() -> String {
    let mut line = String::new();
    io::stdin().read_line(&mut line).unwrap();
    line
}

fn read_as_primitive<T: FromStr>() -> T {
    let s = read_as_line();
    s.trim().parse().ok().expect("failed to parse input")
}

fn main() {
    let n: usize = read_as_primitive();
    let mut a: Vec<i64> = vec![0; n];
    let mut first_two: ((usize, i64), (usize, i64)) = ((0, -10), (0, -10));

    for i in 0..n {
        a[i] = read_as_primitive();
        if (first_two.0).1 < a[i] {
            let prev = first_two.0;
            first_two = ((i, a[i]), prev);
        } else if (first_two.1).1 < a[i] {
            first_two = (first_two.0, (i, a[i]));
        }
    }

    for i in 0..n {
        if i == (first_two.0).0 {
            println!("{}", (first_two.1).1);
        } else {
            println!("{}", (first_two.0).1);
        }
    }

}