nts 定義 -m 由於 nbsp contains notes sam --

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
*/

hdu4671 思維構造