Topcoder_158

【问题描述】
    给定一个歌曲数组songs，每个元素都是一个歌曲的信息，这些信息由乐队、专辑、歌曲名组成，该三部分内容都是由非空的小写字母组成。现在要求将所有的歌曲按照字母顺序进行排序。
    每个歌曲信息的组成方式可能是以下6种之一：”乐队 专辑 歌曲名“、”乐队 歌曲名 专辑“、”专辑 歌曲名 乐队“、”专辑 乐队 歌曲名“、”歌曲名 专辑 乐队“、”歌曲名 乐队 专辑“。
    不同的曲目在这个列表中可以是任意一种表现形式，而且不同曲目的形式之间是没有任何联系的。现在需要找出在这个曲目数组中songs[0] 标识的曲目，在最终排序列表中可能排在的位置（不同的组成方式会影响排序的结果）。按照升序排列返回一个整形数组，其中包含所有可能位置的索引值。

 定义：
类  SongsList
方法  public int[] getPositions(String[] songs)

 约束：
1、songs数组包括1至50个元素（包括）
2、每个曲目字符串包括5至50个字符（包括）
3、曲目都是按照”乐队 专辑 歌曲名“格式组织信息的，而且三部分均不为空并且由小写字母组成
4、每个曲目无论按照何种方式排列，它们都是不同的曲目。

 测试用例：
1、
{ "beatles help yesterday",
  "queen innuendo showmustgoon",
  "eagles hotelcalifornia hotelcalifornia" }
  Returns: {0, 1, 2 }

2、
{ "a a a",
  "b b b",
  "c c c" }
Returns: {0 }

3、
{ "b e h",
  "i i i",
  "g g g",
  "f f f",
  "d d d",
  "c c c",
  "a a a" }
Returns: {1, 3, 5 }

1. import java.util.ArrayList;
2. import java.util.Arrays;
3. import java.util.List;
5. public class SongsList {
6.     private String[][] allSong;
8.     private void setSongsArray(String[] songs) {
9.         allSong = new String[songs.length][6];
10.         String[] tmp;
11.         for (int i = 0; i < songs.length; i++) {
12.             tmp = songs[i].split("//s");
13.             allSong[i][0] = tmp[0] + " " + tmp[1] + " " + tmp[2];
14.             allSong[i][1] = tmp[0] + " " + tmp[2] + " " + tmp[1];
15.             allSong[i][2] = tmp[1] + " " + tmp[0] + " " + tmp[2];
16.             allSong[i][3] = tmp[1] + " " + tmp[2] + " " + tmp[0];
17.             allSong[i][4] = tmp[2] + " " + tmp[1] + " " + tmp[0];
18.             allSong[i][5] = tmp[2] + " " + tmp[0] + " " + tmp[1];
19.         }
20.         Arrays.sort(allSong[0]);
21.     }
23.     private int[] getPos(int[] pos){
24.         List<Integer> resList = new ArrayList<Integer>();
25.         for (int i = 0; i < pos.length; i++) {
26.             if (pos[i] == 2)
27.                 resList.add(i);
28.         }
29.         int[] res = new int[resList.size()];
30.         for (int i = 0; i < res.length; i++) {
31.             res[i] = resList.get(i);
32.         }
33.         return res;
34.     }
35.     
36.     public int[] getPositions(String[] songs) {
37.         int[] pos = new int[songs.length];
38.         setSongsArray(songs);
40.         int[] start=new int[6];
41.         int[] index=new int[6];
42.         for (int i = 0; i < 6; i++) {
43.             int[] flag = new int[songs.length];
44.             for (int k = 1; k < songs.length; k++) {
45.                 for (int n = 0; n < 6; n++) {
46.                     if (allSong[k][n].compareTo(allSong[0][i]) <= 0) {
47.                         flag[k]++;
48.                     }
49.                 }
50.             }
51.             for (int k = 1; k < songs.length; k++) {
52.                 if (flag[k] == 6) {
53.                     start[i]++;
54.                     index[i]++;
55.                 } else if (flag[k] != 0) {
56.                     index[i]++;
57.                 }
58.             }
59.         }
61.         for(int i=0;i<start[0];i++)
62.             pos[i]=1;
63.         for(int i=0;i<index[0]+1;i++)
64.             if(pos[i]==0)
65.                 pos[i]=2;
66.         for(int i=1;i<6;i++){
67.             for(int k=0; k<start[i]-start[i-1];k++){
68.                 if(pos[start[i-1]+k]==0)
69.                     pos[start[i-1]+k]=1;
70.             }
71.             for(int k=0;k<index[i]+1 && k<pos.length;k++){
72.                 if(pos[k]==0)
73.                     pos[k]=2;
74.             }
75.         }
76.         return getPos(pos);
77.     }
78. }

【算法思想】
    首先先将 songs[0]曲目的各组成方式进行排训，再分别计算各种形式在排序列表中可能存在的位置，得到一定在该曲目之前的数量和可能在其之前的数量，然后再进行最终整合得到其所有可能的位置索引值。定义一个位置数组，固定在其前的位置为1，其可能存在的位置为2，其余位置为0，最终遍历该数组找出为2的即为所有可能的位置。