Good Bye 2014 B. New Year Permutation 并查集 最短路 floyed算法

2024-05-14 11:48

本文主要是介绍Good Bye 2014 B. New Year Permutation 并查集 最短路 floyed算法,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

B. New Year Permutation
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

User ainta has a permutation p1, p2, ..., pn. As the New Year is coming, he wants to make his permutation as pretty as possible.

Permutation a1, a2, ..., an is prettier than permutation b1, b2, ..., bn, if and only if there exists an integer k (1 ≤ k ≤ n) wherea1 = b1, a2 = b2, ..., ak - 1 = bk - 1 and ak < bk 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 pi and pj (1 ≤ i, j ≤ ni ≠ j) if and only ifAi, 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 p1, p2, ..., pn — the permutation p that user ainta has. Each integer between 1and n 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 Ai, 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 where1 ≤ i < j ≤ nAi, j = Aj, i holds. Also, for all integers i where 1 ≤ i ≤ nAi, i = 0 holds.

Output

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

Sample test(s)
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
Note

In the first sample, the swap needed to obtain the prettiest permutation is: (p1, p7).

In the second sample, the swaps needed to obtain the prettiest permutation is (p1, p3), (p4, p5), (p3, p4).

permutation p is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. Thei-th element of the permutation p is denoted as pi. The size of the permutation p is denoted as n.

题意,给出一个初始数列,再给出一个矩阵,确定i j位置是否可以交换。要求最小字典序的数列。

首先给一个简单的想法,如果知道任意两点是否可以交换(包括间接交换),那么,我们只需要从最小的数开始一个一个的确定最小的位置 ,就可以得出答案了。如果要知道间接是否可交换,相当于求,任意两点间,最短路是否可为1,用floyed算法求出,复杂度为o(n ^3)

#define N 305
#define M 100005
#define maxn 205
#define MOD 1000000000000000007
int n,b[N][N],p[N],a[N];
char str[N];
void prin(){FI(n)if(!i)printf("%d",p[i] + 1);elseprintf(" %d",p[i] + 1);printf("\n");
}
int main()
{//freopen("in.txt", "r", stdin);//freopen("out.txt", "w", stdout);while(S(n)!=EOF){FI(n) {S(p[i]);p[i]--;a[p[i]] = i;}FI(n) {SS(str);for(int j = 0;str[j] != '\0';j++){b[i][j] = str[j] == '1'?1:0;}}for(int i = 0;i<n;i++)for(int j = 0;j<n;j++)for(int k = 0;k<n;k++){b[j][k] = max(b[j][k],b[j][i] & b[i][k]);}FI(n){for(int j = 0;j<a[i];j++){if(p[j] > i && b[a[i]][j]){int t = p[j],t2 = a[i];p[j] = i;p[t2] = t;a[i] = j;a[t] = t2;break;}}}prin();}//fclose(stdin);//fclose(stdout);return 0;
}

第二种方法。用并查集优化,由于,在同一个集合内的点,明显,只需要从小到大排(因为同一集合,经过一点变换,一定可以生成各种排列),就一定是最优解了。复杂度,为O(n * n);

#define N 305
#define M 100005
#define maxn 205
#define MOD 1000000000000000007
int n,p[N],num[N];
char str[N];
vector<int> g[N];
struct UnionFind{int fa[N];int findFa(int x){return fa[x] == x? x:fa[x] = findFa(fa[x]);}void init(int n){FI(n) fa[i] = i;}void Uni(int a,int b){fa[findFa(a)] = findFa(b);}
}U;
int main()
{//freopen("in.txt", "r", stdin);//freopen("out.txt", "w", stdout);while(S(n)!=EOF){U.init(n);fill(num,0);FI(n) {S(p[i]);p[i]--;}FI(n) {SS(str);for(int j = 0;str[j] != '\0';j++){if(str[j] == '1'){U.Uni(i,j);}}}FI(n) g[U.findFa(i)].push_back(p[i]);FI(n) if(U.findFa(i) == i) sort(g[i].begin(),g[i].end());FI(n){int fa = U.findFa(i);int t = g[fa][num[fa]++];if(!i)  printf("%d",t + 1);else    printf(" %d",t + 1);}printf("\n");}//fclose(stdin);//fclose(stdout);return 0;
}


这篇关于Good Bye 2014 B. New Year Permutation 并查集 最短路 floyed算法的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/988668

相关文章

Python中的魔术方法__new__详解

《Python中的魔术方法__new__详解》:本文主要介绍Python中的魔术方法__new__的使用,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、核心意义与机制1.1 构造过程原理1.2 与 __init__ 对比二、核心功能解析2.1 核心能力2.2

openCV中KNN算法的实现

《openCV中KNN算法的实现》KNN算法是一种简单且常用的分类算法,本文主要介绍了openCV中KNN算法的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的... 目录KNN算法流程使用OpenCV实现KNNOpenCV 是一个开源的跨平台计算机视觉库,它提供了各

springboot+dubbo实现时间轮算法

《springboot+dubbo实现时间轮算法》时间轮是一种高效利用线程资源进行批量化调度的算法,本文主要介绍了springboot+dubbo实现时间轮算法,文中通过示例代码介绍的非常详细,对大家... 目录前言一、参数说明二、具体实现1、HashedwheelTimer2、createWheel3、n

SpringBoot实现MD5加盐算法的示例代码

《SpringBoot实现MD5加盐算法的示例代码》加盐算法是一种用于增强密码安全性的技术,本文主要介绍了SpringBoot实现MD5加盐算法的示例代码,文中通过示例代码介绍的非常详细,对大家的学习... 目录一、什么是加盐算法二、如何实现加盐算法2.1 加盐算法代码实现2.2 注册页面中进行密码加盐2.

Java时间轮调度算法的代码实现

《Java时间轮调度算法的代码实现》时间轮是一种高效的定时调度算法,主要用于管理延时任务或周期性任务,它通过一个环形数组(时间轮)和指针来实现,将大量定时任务分摊到固定的时间槽中,极大地降低了时间复杂... 目录1、简述2、时间轮的原理3. 时间轮的实现步骤3.1 定义时间槽3.2 定义时间轮3.3 使用时

如何通过Golang的container/list实现LRU缓存算法

《如何通过Golang的container/list实现LRU缓存算法》文章介绍了Go语言中container/list包实现的双向链表,并探讨了如何使用链表实现LRU缓存,LRU缓存通过维护一个双向... 目录力扣:146. LRU 缓存主要结构 List 和 Element常用方法1. 初始化链表2.

Python中__new__()方法适应及注意事项详解

《Python中__new__()方法适应及注意事项详解》:本文主要介绍Python中__new__()方法适应及注意事项的相关资料,new()方法是Python中的一个特殊构造方法,用于在创建对... 目录前言基本用法返回值单例模式自定义对象创建注意事项总结前言new() 方法在 python 中是一个

golang字符串匹配算法解读

《golang字符串匹配算法解读》文章介绍了字符串匹配算法的原理,特别是Knuth-Morris-Pratt(KMP)算法,该算法通过构建模式串的前缀表来减少匹配时的不必要的字符比较,从而提高效率,在... 目录简介KMP实现代码总结简介字符串匹配算法主要用于在一个较长的文本串中查找一个较短的字符串(称为

通俗易懂的Java常见限流算法具体实现

《通俗易懂的Java常见限流算法具体实现》:本文主要介绍Java常见限流算法具体实现的相关资料,包括漏桶算法、令牌桶算法、Nginx限流和Redis+Lua限流的实现原理和具体步骤,并比较了它们的... 目录一、漏桶算法1.漏桶算法的思想和原理2.具体实现二、令牌桶算法1.令牌桶算法流程:2.具体实现2.1

Python中的随机森林算法与实战

《Python中的随机森林算法与实战》本文详细介绍了随机森林算法,包括其原理、实现步骤、分类和回归案例,并讨论了其优点和缺点,通过面向对象编程实现了一个简单的随机森林模型,并应用于鸢尾花分类和波士顿房... 目录1、随机森林算法概述2、随机森林的原理3、实现步骤4、分类案例:使用随机森林预测鸢尾花品种4.1