hihoCoder编程练习赛52

题目1 : 字符串排序

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

一般我们在对字符串排序时，都会按照字典序排序。当字符串只包含小写字母时，相当于按字母表"abcdefghijklmnopqrstuvwxyz"的顺序排序。

现在我们打乱字母表的顺序，得到一个26个字母的新顺序。例如"bdceafghijklmnopqrstuvwxyz"代表'b'排在'd'前，'d'在'c'前，'c'在'e'前……

给定N个字符串，请你按照新的字母顺序对它们排序。

输入

第一行包含一个整数N。(1 <= N <= 1000)

第二行包含26个字母，代表新的顺序。

以下N行每行一个字符串S。 (|S| <= 100)

输出

按新的顺序输出N个字符串，每个字符串一行。

样例输入

5
bdceafghijklmnopqrstuvwxyz
abcde
adc
cda
cad
ddc

样例输出

ddc
cda
cad
abcde
adc

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>

 using namespace std;

 int ord[];

 struct Node{
     string str;
     bool operator<(Node x) const{
         int len1 = str.length();
         int len2 = x.str.length();
         for(int i = ; i < len1 && i < len2; i++){
             if(str[i] == x.str[i])continue;
             return ord[str[i]-'a'] < ord[x.str[i]-'a'];
         }
         if(len1 < len2)return true;
         else return false;
     }
 }node[];

 int main()
 {
     int n;
     string str;
     while(cin>>n){
         cin>>str;
         for(int i = ; i < ; i++){
             ord[str[i]-'a'] = i;
         }
         for(int i = ; i < n; i++){
             cin>>node[i].str;
         }
         sort(node, node+n);
         for(int i = ; i < n; i++)
               cout<<node[i].str<<endl;
     }

     return ;
 }

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

 public class Main {

     public static void main(String[] args) {
         Scanner cin = new Scanner(System.in);
         int n;
         String str;
         while(cin.hasNext()) {
             n = cin.nextInt();
             str = cin.next();
             Node.calOrd(str);
             Node[] nodes = new Node[n];
             for(int i = 0; i < n; i++) {
                 String ss = cin.next();
                 nodes[i] = new Node(ss);
             }
             Arrays.sort(nodes);
             for(Node node: nodes) {
                 System.out.println(node.sb.toString());
             }
         }
     }
 }

 class Node implements Comparable<Node>{
     static int[] ord = new int[26];
     public String sb;

     Node(String _str) {
         this.sb = _str;
     }

     static public void calOrd(String str) {
         for(int i = 0; i < 26; i++) {
             ord[str.charAt(i)-'a'] = i;
         }
     }

     public void setSb(String _sb) {
         this.sb = _sb;
     }

     public int compareTo(Node x) {
         int len1 = sb.length();
         int len2 = x.sb.length();
         for(int i = 0; i < len1 && i < len2; i++) {
             if(sb.charAt(i) == x.sb.charAt(i))continue;
             return ord[sb.charAt(i)-'a'] < ord[x.sb.charAt(i)-'a'] ? -1 : 1;
         }
         if(len1 < len2)return -1;
         else return 1;
     }
 }

Java

题目2 : 亮灯方案

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

NxM盏灯组成了一个N行M列的矩阵，其中有些(至少一盏)灯是亮的，有些(至少一盏)是灭的。

现在小Hi希望点亮全部的灯。他每次可以选择一盏熄灭的灯点亮，前提是这盏灯与至少一盏亮的灯相邻(上下左右四个方向）。

请你计算小Hi一共有多少种不同的点亮顺序。

输入

第一行包含两个整数N和M。(1 <= N * M <= 20)

以下N行M列是一个01矩阵，0代表灭，1代表亮。

输出

一个整数代表答案

样例输入

2 2
10
00

样例输出

4

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <map>

 using namespace std;

 const int dx[] = {, , , -};
 const int dy[] = {, , -, };
 map<string, long long> dp;
 string M[];
 int n, m;

 bool isOK(int x, int y){
     for(int i = ; i < ; i++){
         int nx = x + dx[i];
         int ny = y + dy[i];
         if(nx <  || nx >= n || ny <  || ny >= m)
           continue;
         if(M[nx][ny] == '')return true;
     }
     return false;
 }

 string toString(){
     string str(n*m, '');
     for(int i = ; i < n; i++)
       for(int j = ; j < m; j++)
         str[i*m+j] = M[i][j];
     return str;
 }

 long long dfs(int mie){
     if(mie == )return ;
     if(dp[toString()] != )return dp[toString()];
     dp[toString()] = ;
     long long sum = ;
     for(int i = ; i < n; i++){
         for(int j = ; j < m; j++){
             if(M[i][j] == '' && isOK(i, j)){
                 M[i][j] = '';
                 sum += dfs(mie-);
                 M[i][j] = '';
             }
         }
     }
     return dp[toString()] = sum;
 }

 int main()
 {
     while(cin>>n>>m){
         int mie = ;
         dp.clear();
         for(int i = ; i < n; i++){
             cin>>M[i];
             for(int j = ; j < m; j++){
                 if(M[i][j] == '')mie++;
             }
         }
         cout<<dfs(mie)<<endl;
     }

     return ;
 }

 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Scanner;

 public class Main {
     static int[] dx = {0, 1, 0, -1};
     static int[] dy = {1, 0, -1, 0};
     static StringBuilder[] M = new StringBuilder[20];
     static int n, m;
     static Map<String, Long> dp = new HashMap<String, Long>();

     static String MtoString() {
         StringBuilder sb = new StringBuilder("");
         for(int i = 0; i < n; i++) {
             sb.append(M[i]);
         }
         return sb.toString();
     }

     static boolean isOK(int x, int y) {
         for(int i = 0; i < 4; i++){
             int nx = x + dx[i];
             int ny = y + dy[i];
             if(nx < 0 || nx >= n || ny < 0 || ny >= m)
               continue;
             if(M[nx].charAt(ny) == '1')return true;
         }
         return false;
     }

     static long dfs(int mie) {
         if(mie == 1)return 1;
         if(dp.get(MtoString()) != null)return dp.get(MtoString());
         long sum = 0;
         for(int i = 0; i < n; i++){
             for(int j = 0; j < m; j++){
                 if(M[i].charAt(j) == '0' && isOK(i, j)){
                     M[i].setCharAt(j, '1');
                     sum += dfs(mie-1);
                     M[i].setCharAt(j, '0');
                 }
             }
         }
         dp.put(MtoString(), sum);
         return sum;
     }

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

         int mie;
         while(cin.hasNext()) {
             dp.clear();
             n = cin.nextInt();
             m = cin.nextInt();
             mie = 0;
             for(int i = 0; i < n; i++) {
                 M[i] = new StringBuilder(cin.next());
                 for(int j = 0; j < m; j++)
                     if(M[i].charAt(j) == '0')
                         mie++;
             }
             System.out.println(dfs(mie));
         }
     }
 }

Java

题目3 : 部门聚会

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

小Hi在Hihoole公司的实习期结束了。在回学校前，他决定请部门所有同事来住所聚会。

已知小Hi一共有N名同事，编号1~N，其中第i名同事的酒量是Ai。

这N名同事的上下级关系恰好组成一棵树型结构。对于第i名同事来说，如果他的直接上级没有出席聚会，他会喝掉Ai单位的酒；如果他的直接上级出席了聚会，他会有所收敛，只喝掉Ai/2单位的酒。

小Hi想知道，自己至少要准备多少单位的酒，才能保证无论哪些人出席聚会，酒都够喝。

输入

第一行包含一个整数N。(1 <= N <= 100000)

第二行包含N个整数，A1, A2, ... AN。(0 <= Ai <= 100000)

以下N-1行每行包含两个整数u和v，代表u是v的直接上级。

输出

小Hi至少需要准备的酒量，保留1位小数。

样例输入

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

样例输出

10.5

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <vector>

 using namespace std;

 const int N = ;

 double dp[N][];
 int arr[N], fa[N];
 vector<int> vec[N];

 void dfs(int rt){
     int len = vec[rt].size();
     dp[rt][] = arr[rt]*1.0;
     for(int i = ; i < len; i++)
           dfs(vec[rt][i]);
     for(int i = ; i < len; i++){
         dp[rt][] += max(dp[vec[rt][i]][], dp[vec[rt][i]][]);
         dp[rt][] += max(dp[vec[rt][i]][] - 0.5*arr[vec[rt][i]], dp[vec[rt][i]][]);
     }
 }

 int main()
 {
     int n;
     while(cin>>n){
         memset(dp, , sizeof(dp));
         for(int i = ; i <= n; i++){
             cin>>arr[i];
             fa[i] = -;
             vec[i].clear();
         }
         int u, v;
         for(int i = ; i < n-; i++){
             cin>>u>>v;
             fa[v] = u;
             vec[u].push_back(v);
         }
         int root = ;
         while(fa[root] != -)root = fa[root];
         dfs(root);
         printf("%.1f\n", max(dp[root][],dp[root][]));
     }

     return ;
 }

 import java.util.*;

 public class Main {
     static final int N = 100005;
     static double[][] dp = new double[N][2];
     static int [] arr = new int[N];
     static int [] fa = new int[N];
     static Vector<Integer> [] vec = new Vector[N];

     static void dfs(int rt) {
         int len = vec[rt].size();
         dp[rt][1] = arr[rt];
         for(int v: vec[rt]) {
             dfs(v);
         }
         for(int v: vec[rt]) {
             dp[rt][0] += Math.max(dp[v][0], dp[v][1]);
             dp[rt][1] += Math.max(dp[v][1]-0.5*arr[v], dp[v][0]);
         }
     }

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

         int n;
         while(cin.hasNext()) {
             n = cin.nextInt();
             for(int i = 1; i <= n; i++) {
                 dp[i][0] = dp[i][1] = 0;
                 arr[i] = cin.nextInt();
                 fa[i] = -1;
                 vec[i] = new Vector<Integer>();
             }
             int u, v;
             for(int i = 0; i < n-1; i++) {
                 u = cin.nextInt();
                 v = cin.nextInt();
                 fa[v] = u;
                 vec[u].add(v);
             }
             int root = 1;
             while(fa[root] != -1)root = fa[root];
             dfs(root);
             System.out.printf("%.1f\n", Math.max(dp[root][0], dp[root][1]));
         }
     }
 }

Java