CF - 500B New Year Permutation

New Year Permutation

Time Limit:2000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u

Description

User ainta has a permutation（排列） p₁, p₂, ..., p_n. As the New Year is coming, he wants to make his permutation as pretty as possible.

Permutation a₁, a₂, ..., a_n is prettier than permutation b₁, b₂, ..., b_n, if and only if there exists an integer k (1 ≤ k ≤ n) where a₁ = b₁, a₂ = b₂, ..., a_k - 1 = b_k - 1 and a_k < b_k all holds.

As known, permutation p is so sensitive that it could be only modified（修改） by swapping two distinct elements. But swapping two elements is harder than you think. Given an n × n binary matrix（二阶矩阵） A, user ainta can swap the values of p_i and p_j (1 ≤ i, j ≤ n, i ≠ j) if and only if A_i, j = 1.

Given the permutation p and the matrix A, user ainta wants to know the prettiest permutation that he can obtain.

Input

The first line contains an integer n (1 ≤ n ≤ 300) — the size of the permutation p.

The second line contains n space-separated integers p₁, p₂, ..., p_n — the permutation p that user ainta has. Each integer between 1 andn occurs exactly once in the given permutation.

Next n lines describe the matrix A. The i-th line contains n characters '0' or '1' and describes the i-th row of A. The j-th character of thei-th line A_i, j is the element on the intersection of the i-th row and the j-th column of A. It is guaranteed that, for all integers i, j where 1 ≤ i < j ≤ n, A_i, j = A_j, i holds. Also, for all integers i where 1 ≤ i ≤ n, A_i, i = 0 holds.

Output

In the first and only line, print n space-separated integers, describing the prettiest permutation that can be obtained.

Sample Input

Input

7
5 2 4 3 6 7 1
0001001
0000000
0000010
1000001
0000000
0010000
1001000

Output

1 2 4 3 6 7 5

Input

5
4 2 1 5 3
00100
00011
10010
01101
01010

Output

1 2 3 4 5

Hint

In the first sample, the swap needed to obtain the prettiest permutation is: (p₁, p₇).

In the second sample, the swaps needed to obtain the prettiest permutation is (p₁, p₃), (p₄, p₅), (p₃, p₄).

A permutation p is a sequence of integers p₁, p₂, ..., p_n, consisting of n distinct positive integers, each of them doesn't exceed n. The i-th element of the permutation p is denoted as p_i. The size of the permutation p is denoted as n.

---

题意：给你一组排列P的数和一个二阶矩阵A，当且仅当矩阵A的元素为1时，数列P所对应的行和列的数字可以交换。你的任务就是通过这种方式，使数列P中较小的元素尽量靠前。

解题思路：刚开始看这道题时以为简简单单的把可以调换的两个数比较一下，小的在前就行了。但这只是想想，还是没理解题意，事实上没那么简单。。（在此之前要加上个Floyd三层循环，把所有可以调换的数（包括直接，间接）都先找出来，然后再比较可以调换的数就行了。。）

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
char map[310][310];
int main(){
	int n;int a[310];
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	for(int i=0;i<n;i++){
		scanf("%s",map[i]);//老套路，按字符串输入 
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			for(int k=0;k<n;k++){
				if(map[j][i]=='1'&&map[i][k]=='1'){
					map[j][k]='1';//把间接的可以调换的转换成直接的 
				}
			}	
		}
	}
//	for(int i=0;i<n;i++){
//		printf("%s\n",map[i]);
//	}
	for(int i=0;i<n;i++){
		for(int j=i+1;j<n;j++){
			if(map[i][j]=='1'&&a[i]>a[j]){//直接判断就行啦！ 
				swap(a[i],a[j]);
			}
		}
	}
	for(int i=0;i<n;i++){
		printf("%d ",a[i]);
	}
	return 0;
}