MiniMax????

Hej...

VI har et(mange) problemer med vores kalaha... Hvad er problemet? .. Hvorfor vælger den ikke den mest optimale løsning efter første træk?

<LIDT KODE>
/* En tabel til alle huller i spillet
    Sort metode
    hvid metode
    evaluerings metode
*/

import java.io.*;
import java.util.*;

public class Class1
{
    static public int værdi=0,bedste_hul=0;
    static public int n=3;
    static public int[]kalaha = {5,5,5,5,5,5,0,5,5,5,5,5,5,0};  // tabel til spillets \"huller\"

    static public boolean igen=false;
   
    public static void main (String[] args) throws IOException
    {                   
        pc(kalaha, -10000, 10000, n);
        traek(bedste_hul);
        vis_braet(kalaha);
        System.in.read();
    }
   
   
   
    public static int pc (int kalaha[], int alfa, int beta, int n)
    {
        int max=0,bedst=0;
        int[]kopi_kalaha = new int [14];       
        for (int bent = 0; bent<kalaha.length; bent++)
        {
            kopi_kalaha[bent] = kalaha[bent];
        }   
       
        if (n==0)
            return kalaha[13]-kalaha[6];
        else
        {
            max=alfa;
            for (int i=7;i<=12;i++)
            {   
                if(kalaha[i]==0)
                {
                    continue;
                }
               
                traek(i);
               
                if(igen==true)
                {
                    igen=false;
                    værdi=pc(kalaha,alfa, beta, n);   
                }
                else
                {   
                    værdi=human(kalaha, max, beta, n-1);
                    //slet(i);
                    if (værdi>max)
                    {
                        max = værdi;
                        bedst=i;
                    }               
                    if (max>=beta)
                    {
                        bedste_hul=bedst;
                        return max;
                    }
                }
                for (int bent = 0; bent<kopi_kalaha.length; bent++)
                {
                    kalaha[bent] = kopi_kalaha[bent];
                }   
            }
            bedste_hul=bedst;
           
            return max;
        }
    }
    //          *********************************************************
    public static int human (int kalaha[], int alfa, int beta, int n)
    {   
        int min=0,bedst=0;
        int[]kopi_kalaha = new int [14];
       
        for (int bent = 0; bent<kalaha.length; bent++)    //laver kopi af bræt
        {
            kopi_kalaha[bent] = kalaha[bent];
        }   
       
        if (n==0)
            return kalaha[13]-kalaha[6];
        else
        {
            min=beta;
            for (int i=0;i<=5;i++)
            {
                if(kalaha[i]==0)
                {
                    continue;
                }
                traek(i);
               
                if(igen==true)
                {
                    igen=false;
                    værdi=human(kalaha, alfa, beta, n);   
                }
                else
                {
                    værdi=pc(kalaha, alfa, min, n-1);
                    if (værdi<min)
                    {
                        min = værdi;
                        bedst=i;
                    }
                    if (min<=alfa)
                    {
                        bedste_hul=bedst;
                        return min;
                    }
                }
                for (int bent = 0; bent<kopi_kalaha.length; bent++)    //sætter brættet til orginalen
                {
                    kalaha[bent] = kopi_kalaha[bent];
                }   
            }
            bedste_hul=bedst;
           
            return min;
        }
    }
    //                *************************************************************
    public static void traek(int hul)  //metode til at foretage et træk
    {
        int kugler=kalaha[hul];
        int org_hul = hul;
        kalaha[hul]=0;   
        hul++;
        igen=false;
        System.out.println();
   
        for (int i=0;i<kugler;i++)
        {
            if(org_hul<6)
            {   
                if (hul==13)    //putter ikke i modstander kalaha
                    hul=0;
            }       
            if(org_hul>6)
            {
                if(hul==14)        //render rundt
                    hul=0;
                if(hul==6)    //putter ikke i modstander kalaha
                    hul=7;
            }               
            kalaha[hul]++;           
            hul++;
        }   
        if(hul == 14 && org_hul>6)
            igen=true;
       
        if(hul == 7 && org_hul<6)
            igen=true;
       
        //vis_braet(kalaha);
    }
    //                        *********************************************
    public static void vis_braet(int [] kalaha)
    {
        System.out.print(\"    \");
       
        for(int x = 12; x > 6; x--)
        {   
            System.out.print(x + \":\" + kalaha[x] + \" Stk.    \\b\");
        }
   
        System.out.println(\"\\n\");
   
        System.out.println(\"\\t  K1: \" + kalaha[13] + \" Stk.\\t\\t\\t\\t\\t K2: \" + kalaha[6] + \" Stk. \\n\"); 
        System.out.print(\"    \");
   
        for(int x = 0; x <= 5; x++)
        {   
            System.out.print(\" \"+ x + \":\" + kalaha[x] + \" Stk.    \\b\");       
        }
        System.out.println();    System.out.println(); System.out.println(\"\\t_____________________________________________________________  \");   
    }
    //                    **************************************************
   
}


*g*