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