CodeForces-814B An express train to reveries 解题报告

B. An express train to reveries

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Sengoku still remembers the mysterious "colourful meteoroids" she discovered with Lala-chan when they were little. In particular, one of the nights impressed her deeply, giving her the illusion that all her fancies would be realized.

On that night, Sengoku constructed a permutation p1, p2, ..., pn of integers from 1 to n inclusive, with each integer representing a colour, wishing for the colours to see in the coming meteor outburst. Two incredible outbursts then arrived, each with n meteorids, colours of which being integer sequences a1, a2, ..., an and b1, b2, ..., bn respectively. Meteoroids' colours were also between 1 and n inclusive, and the two sequences were not identical, that is, at least one i (1 ≤ i ≤ n) exists, such that ai ≠ bi holds.

Well, she almost had it all — each of the sequences a and b matched exactly n - 1 elements in Sengoku's permutation. In other words, there is exactly one i (1 ≤ i ≤ n) such that ai ≠ pi, and exactly one j (1 ≤ j ≤ n) such that bj ≠ pj.

For now, Sengoku is able to recover the actual colour sequences a and b through astronomical records, but her wishes have been long forgotten. You are to reconstruct any possible permutation Sengoku could have had on that night.

Input

The first line of input contains a positive integer n (2 ≤ n ≤ 1 000) — the length of Sengoku's permutation, being the length of both meteor outbursts at the same time.

The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n) — the sequence of colours in the first meteor outburst.

The third line contains n space-separated integers b1, b2, ..., bn (1 ≤ bi ≤ n) — the sequence of colours in the second meteor outburst. At least one i (1 ≤ i ≤ n) exists, such that ai ≠ bi holds.

Output

Output n space-separated integers p1, p2, ..., pn, denoting a possible permutation Sengoku could have had. If there are more than one possible answer, output any one of them.

Input guarantees that such permutation exists.

Examples

input

51 2 3 4 31 2 5 4 5

output

1 2 5 4 3

input

54 4 2 3 15 4 5 3 1

output

5 4 2 3 1

input

41 1 3 41 4 3 4

output

1 2 3 4

Note

In the first sample, both 1, 2, 5, 4, 3 and 1, 2, 3, 4, 5 are acceptable outputs.

In the second sample, 5, 4, 2, 3, 1 is the only permutation to satisfy the constraints.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

题目大意：

  给你两个长度为n的序列a,b，让你求一个序列p，他满足，和a有一个元素不同，和b有一个元素不同，且是n的全排列，让你输入任意一种满足题意的序列p。

解题思路：

  没思路，参考别人的博客(- _ -|||)。a和b有i个位置的数是不相同的。其实，在一定有解的情况下，这个 i 只能为 1 （test3）或者 2（这个情况比较多）。

  1)当有一个位置不同时，我们记录出现过那些数，剩下的一个填入这个位置中
  2)当有两个位置不同时，我们记录剩下的两个空位，判断取a或b在该位的数是否会导致重复

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
int n;
int a[1005];
int b[1005];
int c[1005];//所求的P
int tot;//不同位置的个数
int now;//记录一个不同位置时的 位置
int d[3];//记录两个位置不同时的 位置
bool vis[1005];//标记1~n的数字是否被使用过
int main()
{
    int n;
    cin>>n;
    for (int i=1; i<=n; i++)
        scanf("%d", &a[i]);
    for (int j=1; j<=n; j++)
        scanf("%d", &b[i]);
    for (int i=1; i<=n; i++)
        if (b[i]!=a[i])
            tot++;
    if (tot==1)
    {
        for (int i=1; i<=n; i++)
        {
            if (a[i]==b[i])
            {
                c[i]=a[i];
                vis[c[i]]=1; //相同位置时，将所在位置的数字标记
            }
            else   
                now=i; //找出不同时的位置                
        }
        for (int i=1; i<=n; i++)
        {
            if (vis[i]==false)
            {
                c[now]=i;
                break;
            }
        }
    }
    else//当有两个位置不同时，我们记录剩下的两个空位，判断取a或b在该位的数是否会导致重复
    {
        for (int i=1; i<=n; i++)
        {
            if (a[i]==b[i])
            {
                c[i]=a[i];
                vis[c[i]]=1;//相同位置时，将所在位置的数字标记
            }
            else
                d[tot--]=i;//找出不同位置
            if (a[d[1]] == b[d[2]] || vis[a[d[1]]] || vis[b[d[2]]])//先考虑c[d[i]]取a[d[1]]
            {
                c[d[1]] = b[d[1]];
                c[d[2]] = a[d[2]];
            }
            else
            {
                c[d[1]]=a[d[1]];
                c[d[2]]=b[d[2]];
            }
        }
    }
    for (int i=1; i<=n; i++)
        cout<<c[i]<<" ";
    return 0;
}