百度“变态比赛规则”算法题 java 的解法

这个...
如果连
这个公式在10秒钟内推导(不是记住)不出来,我有理由怀疑他有没有做程序员的能力.
而且我不赞同JAVA的思考方式是这样的.

呵呵
如果可以选，我会选给程序员写程序而不是给不懂行的写程序，
但事实总是与我们开玩笑。

我只是说为了合乎逻辑。。。。
防止别人看不懂，但是从早上起N个人问过我为什么不用Sn(n)了。。。
这点的需求作的有点过了。。。

@_@

Sn(n)是啥东西

等差数列合公式。。。
PS：强烈怀疑你的语言真实性
PS2：学这个公式时老是除出 xxx.5的人飘过。。。。
PS3:n!这东西是个好东西如果有好的手算办法给我发一份。。。

写了个程序，不知道对不对，呵呵，不过计算比较麻烦，应该还能简单很多
public class Team {
private int membercount;

private int times;

/**
* @return membercount
*/
public int getMembercount() {
return membercount;
}

/**
* @param membercount
*/
public void setMembercount(int membercount) {
this.membercount = membercount;
}

/**
* @return times
*/
public int getTimes() {
initTimes();
return times;
}

private void initTimes() {
times = (membercount*membercount-membercount)/2;
}

}
写了个算法
import java.util.*;

public class Match {
private int totalcount;

private int mostTimes;

private int leastTimes;

private int times;

private int remaintimes;

private List<Team> teams = new ArrayList();

private int teamMemebers;

/**
* @return leastTimes
*/
public int getLeastTimes() {
return leastTimes;
}

/**
* @return mostTimes
*/
public int getMostTimes() {
return mostTimes;
}

public Match(int totalcount){
this.totalcount = totalcount;
leastTimes = totalcount-1;
mostTimes = countTimes(totalcount);
}

/**
* @return totalcount
*/
public int getTotalcount() {
return totalcount;
}

public static int countTimes(int i){
if(i==1)
return 0;
if(i==2)
return 1;
return (i*i-i)/2;
}

public boolean isCanPlay(){
boolean result = false;
if(times<leastTimes)
return false;
if(times>mostTimes)
return false;
if(times==leastTimes)
return true;
if(times==mostTimes)
return true;
while(remaintimes!=0){
if(teamMemebers>totalcount)
return false;
createTeam(remaintimes);
}
if(teamMemebers>totalcount)
return false;
return true;
}

public void createTeam(int m){
Team team = new Team();
if(m==1){
team.setMembercount(2);
teamMemebers = teamMemebers+2;
teams.add(team);
remaintimes = remaintimes-1;
System.out.println("teamMemebers is "+teamMemebers);
return;
}
int j = (m<=2)?5:2*m;
for(int i =2;i<=j;i++){
System.out.println("i is "+i);
if(countTimes(i)>m){
remaintimes = remaintimes-countTimes(i-1);
teamMemebers = teamMemebers+i-1;
System.out.println("teamMemebers is "+teamMemebers);
team.setMembercount(i-1);
return;
}
}
teams.add(team);
}

/**
* @return times
*/
public int getTimes() {
return times;
}

/**
* @param times 要设置的 times
*/
public void setTimes(int times) {
this.times = times;
System.out.println("mostTimes is "+mostTimes);
this.remaintimes = this.mostTimes - times;
System.out.println("remaintimes is "+remaintimes);
}

public static void main(String[] args){
Match m = new Match(10);
m.setTimes(32);
try{
if(m.isCanPlay()){
System.out.println("Can");
}else{
System.out.println("Can not");
}
}catch(Exception e){
e.printStackTrace();
}
}
}

    private static int offset(int n){  //表示第n个的起始位置   
          return  n*(n-1)*(n-2)/6 + n;   
    }

这个是由Sum{i*(i-1)/2; 1<=i<=n}计算出来的么？偶怎么就算不出来

Match m = new Match(10); //用于建立多少人的比赛
m.setTimes(32);
比赛一共的场次
m.isCanPlay() //是否存在这样的分组
想法是这样的，计算出10个人最多的比赛数，然后通过要比赛的场次，计算出不需要进行多少场，然后分组，分组的时候计算分组时可以不用参加的比赛，如果存在这样的分组并且人数不大于参赛人数，那么就可行

算法中使用逼近方法，每次分组的时候 小组中不用比赛的次数逼近一共不需要比赛的次数，即一次能分组的最大人数。

(m*m-m)/2 中m取最大值；

并认为如果这种最大分组不存在即不存在这样的分组

    public static boolean isSuit(int n,int k){   
          if(k<0||k>n*(n-1)/2) return false;   
          int off =offset(n);   
          if(isSolved.get(off+k)) return isSuit.get(off+k);   
          for(int i =1;i<n;i++)   
              if(isSuit(n -i,k -i*(n-i) ) ){   
                  isSolved.set(off +k);   
                  isSuit.set(off +k);   
                  return true;   
              }   
          isSolved.set(off +k);   
          return false;   
    }   

呵呵，这里用递归会影响性能，如果改成循环的话就更好了

这就是引用数学公式的问题，前题是对方得懂公式才可以
"n!/(3!)(n-3)! + n"

为什么是这个公式？？？有点看不懂