hdu4671 思惟構造

http://acm.hdu.edu.cn/showproblem.php?pid=4671

Problem Description

Makomuno has N servers and M databases. All databases are synchronized among all servers and each database has a ordered list denotes the priority of servers to access. This list is guaranteed to be a valid permutation of all servers.
Every time someone wants to execute queries on a certain database, he will send a request to the first server in the list. If it's dead, he will simply turn to the next one. Otherwise a working copy of the database is found, and this copy is called active.
Now, given N and M, Makomuno wants to find a permutation for each database which could assure that all servers are load-balanced. Moreover, Makomuno hopes the system will be load-balanced even if  exactly one server is broken.
Note that if we call the number of active copies on i-th server A _i, then load-balanced means max∣A _i - A _j∣≤1 for any i and j in non broken servers set. We won't consider broken servers in this case.

 

Input

The input contains several test cases, terminated by EOF.
Each test case has one line containing two integer N ( 2≤N≤100) and M ( 1≤M≤100).

 

Output

For each case output M lines, the i-th line contains a permutation of all servers, indicating the expected order. Servers are numbered from 1 to n.

 

Sample Input

   
   
   
   

    
    
    
    5 3
   
   
   
   

 

Sample Output

   
   
   
   

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

    
    
    
    
 
     
 
      Hint 
     
 In the sample test case, the active copies of these databases are on server 2,1 and 3 in normal state. A = {1,1,1,0,0} If server 1 or 3 has broken, server 5 will take its work. In case we lost server 2, the second database will use server 4 instead. A = {1,BROKEN,1,1,0} It's clear that in any case this system is load-balanced according to the plan in sample output. 
    
    
    
    
     
   
   
   
   

/**
hdu4671  思惟構造
題目大意：有n臺server和m個數據庫，咱們要用server執行數據庫，對於每個數據庫被執行server的優先級爲1~n的一個排列。每個數據庫僅僅執行一次，
           問如何定義m個數據庫的優先級，若是有一臺server壞了的狀況下仍然知足每臺server的執行數據庫的數量差不能大於1
解題思路：這個題是一個考驗思惟的題。固然答案有很是多。
我僅僅要肯定每個數據庫優先級最高和次高的就可以了。咱們分兩種狀況來討論：
           1.n>=m 在這樣的狀況下1~m第一優先級的爲1~m，第二優先級的爲餘下的隨意（若n==m，則所有隨意。要保證第一第二不能是一個數）
           2.n<m  在這樣的狀況下1~m爲1~n。再1~n。知道循環夠m。第二優先級，咱們對於第一優先級同樣的放在一塊考慮，從n~1循環（和第一反覆就跳過）。
           爲何這樣呢？因爲若是i壞了，那麼第二優先級添加的仍是各一個，仍保證是對的。注意要n~1循環，因爲第m不必定是n的倍數。因此有i~n
           可能會在第一優先級裏少排一個，咱們在第二優先級裏要優先考慮，不然會出現有一個壞了的話差大於1的狀況
*/
#include <string.h>
#include <stdio.h>
#include <iostream>
#include <algorithm>
using namespace std;
int n,m,a[105][2],flag[105];
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        if(n>=m)
        {
            for(int i=1;i<=m;i++)
            {
                a[i][0]=i;
                if(a[i][0]==n)
                   a[i][1]=1;
                else
                   a[i][1]=n;
            }
        }
        else
        {
            for(int i=1;i<=m;i++)
            {
                a[i][0]=(i%n==0)?
n:i%n;
            }
            for(int i=1;i<=n;i++)
            {
                int k=n;
                for(int j=1;j<=m;j++)
                {
                    if(a[j][0]==i)
                    {
                        k=(k%n==0)?
n:k%n;
                        if(k==i)k--;
                        k=(k%n==0)?
n:k%n;
                        a[j][1]=k--;
                       // printf("??%d:%d\n",a[j][0],a[j][1]);
                    }
                }
            }
        }
        for(int i=1;i<=m;i++)
        {
            //printf(">>%d %d\n",a[i][0],a[i][1]);
        }
        for(int i=1;i<=m;i++)
        {
            memset(flag,0,sizeof(flag));
            printf("%d %d",a[i][0],a[i][1]);
            flag[a[i][0]]=flag[a[i][1]]=1;
            for(int j=1;j<=n;j++)
            {
                while(flag[j])j++;
                if(j>n)break;
                printf(" %d",j);
                flag[j]=1;
            }
            printf("\n");
        }
    }
    return 0;
}
/**
3 14
answer：
1 3 2
2 3 1
3 2 1
1 2 3
2 1 3
3 1 2
1 3 2
2 3 1
3 2 1
1 2 3
2 1 3
3 1 2
1 3 2
2 3 1
*/