亚洲视频一区二区在线观看,国产亚洲漂亮白嫩美女在线,亚洲免费观看网站

矛_��@ — Sat, 15 Aug 2009 09:25:00 GMT

�q�几天一直在搞关于优先��队列的实�?因�ؓ要考虑到线�E�的安全,所以PriorityQueue��׃��适用了。一个非常简单的实现�? 法，那就是把优先�U�比较好的插入一个队列，优先�U�低的插入另一个队列，取数的时候先在优先��高的队列上取数。这有个�~�点��是如果优先�U�别��多的话�Q�队列就 ��多�?/div>

因�ؓ要线�E�安全，队列采用ConcurrentLinkedQueue�q�个�U�程安全的，而api文档上说ConcurrentLinkedQueue采用了有效的“无等�?(wait-free)”��法�Q�所以它的吞吐量是很不错的！

��单代码如下：

package test;
import java.util.concurrent.ConcurrentLinkedQueue;
public class PriorityQueueTest {
public static void main(String[] args) {
ConcurrentLinkedQueue highPriority = new ConcurrentLinkedQueue(); //高优先��
ConcurrentLinkedQueue lowPriority = new ConcurrentLinkedQueue(); //低优先��
highPriority.add("aaa");
highPriority.add("bbb");
highPriority.add("111");
lowPriority.add("ccc");
lowPriority.add("ddd");
lowPriority.add("222");
int i = 0 ,j = 0, k=0;
while(true){
while(true){
if(!highPriority.isEmpty()){
System.out.print(highPriority.remove());
i++;
k++;
System.out.println(", i = "+i+", k="+k);
break;
}
if(!lowPriority.isEmpty()){
System.out.print(lowPriority.remove());
j++;
k++;
System.out.println(", j = "+j+", k="+k);
break;
}
break;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

�q�有一�U�是�Q�通过�l�承PriorityQueue�q�实�?span class="Apple-style-span" style="color: #333333; line-height: normal;">Comparable接口�Q�然后自已重写过compareTo�Ҏ��p��实现很强大的优先�U�队列了�Q�不�q�缺�Ҏ��U�程不安全的�Q?/span>

代码如下�Q?/div>

package test;

import java.util.PriorityQueue;

public class PriorityTest extends PriorityQueue{
    static class Test implements Comparable{
        String packet;
        int priotity;
        
        public Test(String packet, int priotity) {
            this.packet = packet;
            this.priotity = priotity;
        }
        
        public int compareTo(Test arg) { 
            if(priotity < arg.priotity)
                return 1;
            else if(priotity > arg.priotity)
                return -1;
            else
                return 0;
        } 
        
        public String toString(){
            return packet; 
        }
    }
    
    public void add(String str, int priority){
        super.add(new Test(str,priority));
    }
    
    public static void main(String args[]){
        PriorityTest pTest = new PriorityTest();
        pTest.add("aaa",3);  //优先�U�最�?/span>
        pTest.add("bbb",2);
        pTest.add("ccc",1);
        
        while(!pTest.isEmpty()){
            System.out.println(pTest.remove());
        }
    }
}

摘自�Q�http://blog.csdn.net/liuzhengkang/archive/2009/01/05/3714047.aspx

矛_��@ 2009-08-15 17:25 发表评论

蛇阵��法

矛_��@ — Sun, 26 Jul 2009 01:39:00 GMT

转自�Q�http://m.tkk7.com/nokiaguy/archive/2009/07/24/288163.html

在描�q�算法之前，先看看下面的5*5的表��|��

1	3	4	10	11
2	5	9	12	19
6	8	13	18	20
7	14	17	21	24
15	16	22	23	25

    上面的表格很�Ҏ��看出规律。就是从左上角第一个格开始（起始�?�Q�，然后延右上角到左下角的斜�Uѝ��先从下��C��Q�再从上��C��。开始按数字递增排列。也��是说每一个斜�U�上分别有如下几�l�数字：

1    2 3     4 5 6       7 8 9 10      11 12 13 14 15          16 17 18 19      20 21 22      23 24       25

    �׃��是先从上��C��Q?可以看做是从上到下）�Q�再从下��C��Q�很象一条蛇�Q�因此，该数字表��g��可称��形矩��c��现在要与一个方法（或函敎ͼ��Q�方法的参数是一个int�c�d��Q�表�C�n�Q�方法返回一个二�l�数�l�，表示要获得的往�q�接力数字表根{�?br />     实际上，�q�个��法�q�不复杂�Q�只需要从分别获得1至n^2中每个数字对应的二维数组的坐标就可以了。先拿这�?�?列的表格来说�Q�求��Z��面每�l�数�l�对应的坐标�Q��v始位�|��ؓ0�Q��?br />

�W?�l?br /> �W?�l?br /> �W?�l?br /> �W?�l?br /> �W?�l?br /> �W?�l?br /> �W?�l?br /> �W?�l?br /> �W?�l?br />

1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19
20 21 22
23 24
25

(0,0)
(1,0)   (0,1)
(0,2) (1,1)   (2,0)
(3,0)   (2,1)   (1,2)   (0,3)
(0,4)   (1,3)   (2,2)   (3,1)   (4,0)
(4,1)   (3,2)   (2,3)   (1,4)
(2,4)   (3,3) (4,2)
(4,3)   (3,4)
(4,4)

从上面的从标可以看出一个规律�?nbsp; 左上角的半个表格�Q�以对角�U�分界）的横坐标和纵坐标�?开始，每一�l�增1�Q�直到增臌��格的边界�Q�n - 1�Q�，而且是交替的�Q�也��是��_��偶数行是列增�Q�行减小�Q�行+�?�l�的索引。而右下角�?�l�数字虽然行、列也是交替增长的，但递减的行或列��L��?n - 1)开始（对于本例�Q�是�?开始）�Q�而递增的行或列��L��从index - n + 1开始，其中index表示�l�的索引。这��可以得��Z��个算法。实��C��码如下：

public static int[][] getGrid(int n)
{
    int[][] array = new int[n][n];
    int row = 0, col = 0, m = 1;
    //  用于控制奇偶�l�，false表示偶组�Q�true表示奇组
    boolean isRow = false;
    //  i表示当前�l�的索引�Q�从0开�?/span>
    for (int i = 0; i < (2 * n - 1); i++)
    {
        row = i;
        while (row >= ((i < n) ? 0 : i - n + 1))
        {
            //  如果处理的是右下角表��g��的数字，行或列最大不能超�q�n-1
            if (row > (n - 1))
                row = n - 1;
            col = i - row;
            if (isRow)
                array[row][col] = m;
            else  //  ��row变成列，��col变成�?/span>
                array[col][row] = m;
            m++;
            row--;
        }
        //  切换奇偶�l?/span>
        isRow = !isRow;
    }
    return array;
}

改进��法

上面实现的算法需要��@环N*N�ơ才可以生成蛇�Ş矩阵。但仔细分析一下，�q�可以��l�简化算法，使��@环次数减��至N*N/2�Q�也��是��_��效率可以提高一倍。我们上学时曑֭��q�用高斯的方法计��?+2+3+...+100�Q? 1 + 100 = 101�Q? + 99 = 101�Q?..�Q?0+51 = 101�Q�因此，�l�果�?01 * 50 = 5050。很方便。我们这个算法也可采用类似的�Ҏ��。仔�l�观察上�?*5的数字表格发玎ͼ��出左上角的矩阵中每一个数字后�Q�都可以直接获得右下角度某个�? �|�的数字。例如在(0,0)位置�?�Q�可以向�?4,4)位置�?5�Q?1,2)位置�?可以得到(3,2)位置�?7。我们发玎ͼ�每一�Ҏ��之和都�ؓ 26。而且它们坐标的关�p�L��(row,col)�Q?n - row - 1, n - col - 1)。因此，只要得到左上角的半个矩阵�Q�就可以得出右下角的另外半个矩阵。如果n为奇敎ͼ�对角�U�中间的一个数�Q�在5*5的矩阵中�?3�Q�与之对应的数是�? 自��n。好�Q�我们看看改�q�的��法的实玎ͼ�

public static int[][] getGrid1(int n)
{
    int[][] array = new int[n][n];
    int row = 0, col = 0, m = 1;
    int number1 =  (n * n / 2 + n * n % 2);
    int number2 = n * n + 1;
    boolean isRow = false;
    //  number1表示要计��的蛇�Ş矩阵中最大的数字�Q�对�?*5矩阵来说该数�?3
    for (int i = 0; m < number1; i++)
    {
        row = i;
        while (row >= 0)
        {
            col = i - row;
            if (isRow)
            {
                array[row][col] = m;
                //  填充与m对应的另外一个数
                array[n - row - 1][n - col - 1] = number2 - m;
            }
            else
            {
                array[col][row] = m;
                //  填充与m对应的另外一个数
                array[n - col - 1][n - row - 1] = number2 - m;

            }
            m++;
            if(m >= number1) break;
            row--;
        }
        isRow = !isRow;
    }
    return array;
}

如果惌��出n=10的数字表��|��可以使用int[][] grid = getGrid(10)或int[][] grid1 = getGrid1(10)�Q�会得到同样的结果。输出grid和grid1�Q�看看是不是下面的结果：

1	3	4	10	11	21	22	36	37	55
2	5	9	12	20	23	35	38	54	56
6	8	13	19	24	34	39	53	57	72
7	14	18	25	33	40	52	58	71	73
15	17	26	32	41	51	59	70	74	85
16	27	31	42	50	60	69	75	84	86
28	30	43	49	61	68	76	83	87	94
29	44	48	62	67	77	82	88	93	95
45	47	63	66	78	81	89	92	96	99
46	64	65	79	80	90	91	97	98	100

矛_��@ 2009-07-26 09:39 发表评论

五子��AI��法

矛_��@ — Mon, 13 Jul 2009 10:46:00 GMT

五子��的核心��法

2009�q?4�?2�?星期�?17:55

五子��是一�U�受大众�q�泛喜爱的游戏，其规则简单，变化多端�Q�非常富有趣��x��和消遣性。这里设计和实现了一个�h机对下的五子��程序，采用了博弈树的方法，应用了剪枝和最大最��树原理�q�行搜烦发现最好的下子位置。介�l�五子棋�E�序的数据结构、评分规则、胜负判断方法和搜烦��法�q�程�?

一、相关的数据�l�构
    关于盘面情况的表�C�，以链表�Ş式表�C�当前盘面的情况�Q�目的是可以允许用户�q�行悔棋、回退�{�操作�?
    CList StepList;
    其中Step�l�构的表�C�Zؓ�Q?/p>

    struct Step
    {
      int m; //m,n表示两个坐标�?
      int n;
      char side; //side表示下子�?
    };
以数�l��Ş式保存当前盘面的情况�Q?
目的是�ؓ了在昄��当前盘面情况时��用：
char FiveArea[FIVE_MAX_LINE][FIVE_MAX_LINE];

其中FIVE_MAX_LINE表示盘面最大的行数�?/p>

同时�׃��需要在递归搜烦的过�E�中考虑旉��和空间有效性，只找出就当前情况来说相对比较好的几个盘面�Q�而不是对所有的可下子的位置都进行搜索，�q�里用变量CountList来表�C�当前搜索中可以选择的所有新的盘面情况对象的集合�Q?/p>

CList CountList;
其中�c�CBoardSituiton�?
class CBoardSituation
{
CList StepList; //每一步的列表
char FiveArea[FIVE_MAX_LINE][FIVE_MAX_LINE];
struct Step machineStep; //机器所下的那一�?
double value; //该种盘面状态所得到的分�?
}

二、评分规�?
对于下子的重要性评分，需要从六个位置来考虑当前��局的情况，分别为：-,¦,/,,//,\

实际上需要考虑在这六个位置上某一�Ҏ��形成的子的布局的情况，对于在还没有子的地方落子以后的当前局面的评分�Q�主要是��Z��说明在这个地方下子的重要性程度，讑֮�了一个简单的规则来表�C�当前棋面对机器方的分数�?/p>

基本的规则如下：

判断是否能成5, 如果是机器方的话�l�予100000分，如果是�h方的话给予－100000 分；
判断是否能成�z?或者是双死4或者是�?�z?�Q�如果是机器方的话给�?0000分，如果是�h方的话给予－10000分；
判断是否已成双活3�Q�如果是机器方的话给�?000分，如果是�h方的话给予－5000 分；
判断是否成死3�z?�Q�如果是机器方的话给�?000分，如果是�h方的话给予－1000 分；
判断是否能成�?�Q�如果是机器方的话给�?00分，如果是�h方的话给予－500分；
判断是否能成单活3�Q�如果是机器方的话给�?00分，如果是�h方的话给予－200分；
判断是否已成双活2�Q�如果是机器方的话给�?00分，如果是�h方的话给予－100分；
判断是否能成�?�Q�如果是机器方的话给�?0分，如果是�h方的话给予－50分；
判断是否能成双活2�Q�如果是机器方的话给�?0分，如果是�h方的话给予－10分；
判断是否能成�z?�Q�如果是机器方的话给�?分，如果是�h方的话给予－5分；
判断是否能成�?�Q�如果是机器方的话给�?分，如果是�h方的话给予－3分�?/p>

实际上对当前的局面按照上面的规则的顺序进行比较，如果满��某一条规则的话，��q��该局面打分�ƈ保存�Q�然后退��则的匚w��。注意这里的规则是根据一般的下棋规律的一个�ȝ��Q�在实际�q�行的时候，用户可以��d��规则和对评分机制加以修正�?/p>

三、胜负判�?
实际上，是根据当前最后一个落子的情况来判断胜负的。实际上需要从四个位置判断�Q�以该子为出发点的水�q�I��竖直和两条分别�ؓ 45度角�?35度角的线�Q�目的是看在�q�四个方向是否最后落子的一�Ҏ��成连�l�五个的��子�Q�如果是的话�Q�就表示该盘��局已经分出胜负。具体见下面的图�C�：

四、搜索算法实现描�q?
    注意下面的核心的��法中的变量currentBoardSituation�Q�表�C�当前机器最新的盘面情况, CountList表示�W�一层子节点可以选择的较好的盘面的集合。核心的��法如下�Q?
void MainDealFunction()
{
value=�Q�MAXINT; //对初始根节点的value赋�?
CalSeveralGoodPlace(currentBoardSituation,CountList);
//该函数是�Ҏ��当前的盘面情冉|��比较得到比较好的可以考虑的几个盘面的情况�Q�可以根据实际的得分情况选取分数比较高的几个盘面�Q�也��是说在�W�一层节炚w��择的时候采用贪婪算法，直接扑և�相对分数比较高的几个形成�W�一层节点，目的是�ؓ了提高搜索速度和防止堆栈溢出�?
pos=CountList.GetHeadPosition();
CBoardSituation�Q?pBoard;
for(i=0;ivalue=Search(pBoard,min,value,0);
Value=Select(value,pBoard�Q?gt;value,max);
//取value和pBoard�Q?gt;value中大的赋�l�根节点
}
for(i=0;ivalue)
//扑և�那一个得到最高分的盘�?
{
    currentBoardSituation=pBoard;
    PlayerMode=min; //当前下子�Ҏ��Z�h
    Break;
}
}

其中对于Search函数的表�C�如下：实际上核心的��法是一个剪枝过�E�，其中在这个搜索过�E�中相关的四个参��Cؓ�Q�（1�Q�当前棋局情况�Q�（2�Q�当前的下子方，可以是机�?max)或者是�?min)�Q�（3�Q�父节点的值oldValue�Q�（4�Q�当前的搜烦深度depth�?/p>

double Search(CBoardSituation�Q?
board,int mode,double oldvalue,int depth)
{
CList m_DeepList;
if(deptholdvalue))==    TRUE)
      {
          if(mode==max)
            value=select(value,search(successor
          Board,min,value,depth�Q?),max);
          else
            value=select(value,search(successor
            Board,max,value,depth�Q?),min);
      }
      return value;
}
else
{
if ( goal(board)<>0)
//�q�里goal(board)<>0表示已经可以分出胜负
return goal(board);
else
return evlation(board);
        }
    }

注意�q�里的goal(board)函数是用来判断当前盘面是否可以分��负，而evlation(board)是对当前的盘面从机器的角度进行打分�?/p>

下面是Select函数的介�l�，�q�个函数的主要目的是�Ҏ�� PlayerMode情况�Q�即是机器还是用��h��q�回节点的应有的倹{�?/p>

double Select(double a,double b,int mode)
{
if(a>b �Q�＆ mode==max)¦¦ (a< b �Q�＆ mode==min)
return a;
else
return b;
}

五、小�l?
在Windows操作�pȝ��下，用VC�Q�＋实现了这个�h机对战的五子��程序。和国内许多只是采用规则或者只是采用简单递归而没有剪枝的那些�E�序相比�Q�在智力上和旉��有效性上都要好于�q�些�E�序。同时所讨论的方法和设计�q�程为用戯��计其他的游戏�Q�如象棋和围��等�Q�提供了一个参�?/p>

矛_��@ 2009-07-13 18:46 发表评论

1	3	4	10	11	21	22	36	37	55
2	5	9	12	20	23	35	38	54	56
6	8	13	19	24	34	39	53	57	72
7	14	18	25	33	40	52	58	71	73
15	17	26	32	41	51	59	70	74	85
16	27	31	42	50	60	69	75	84	86
28	30	43	49	61	68	76	83	87	94
29	44	48	62	67	77	82	88	93	95
45	47	63	66	78	81	89	92	96	99
46	64	65	79	80	90	91	97	98	100

1	3	4	10	11	21	22	36	37	55
2	5	9	12	20	23	35	38	54	56
6	8	13	19	24	34	39	53	57	72
7	14	18	25	33	40	52	58	71	73
15	17	26	32	41	51	59	70	74	85
16	27	31	42	50	60	69	75	84	86
28	30	43	49	61	68	76	83	87	94
29	44	48	62	67	77	82	88	93	95
45	47	63	66	78	81	89	92	96	99
46	64	65	79	80	90	91	97	98	100

亚洲视频一区二区在线观看,国产亚洲漂亮白嫩美女在线,亚洲免费观看网站

蛇阵���法

五子���AI���法

蛇阵��法

五子��AI��法

1	3	4	10	11	21	22	36	37	55
2	5	9	12	20	23	35	38	54	56
6	8	13	19	24	34	39	53	57	72
7	14	18	25	33	40	52	58	71	73
15	17	26	32	41	51	59	70	74	85
16	27	31	42	50	60	69	75	84	86
28	30	43	49	61	68	76	83	87	94
29	44	48	62	67	77	82	88	93	95
45	47	63	66	78	81	89	92	96	99
46	64	65	79	80	90	91	97	98	100