BlogJava-Java杂家-随笔分类-Memorandum

有意思的“电灯泡问题”

DoubleH — Wed, 05 Mar 2008 07:00:00 GMT

过道里依次挂着标号是1，2，3, ......，100的电灯泡，开始它们

都是灭着的。当第一个人走过时，他将标号为 1 的倍数的电灯泡的开关

线拉了一下；当第二个人走过时，他将标号为 2 的倍数的电灯泡的开关

线拉了一下；当第三个人走过时，他将标号为 3 的倍数的电灯泡的开关

线拉了一下；......  如此进行下去，当第一百个人走过时，他将标号为

100 的倍数的电灯泡的开关线拉了一下。

问：当第一百个人走过后，过道里亮着的电灯泡标号是多少？





我的思路：

设标号为K的灯泡被拉了L(K)次，那么当L(K)为奇数的时候，灯泡是亮的。

那么那些标号被拉了奇数次呢？

K=1时，很显然是只拉了1次，最后是亮的。

其次K>=2时，据题意，K号灯第1次，和第K次肯定是拉下了，其余的只会被第K的因子次拉，

据因式分解定理，数K分解为

K=p1^(n1)*p2^(n2)*.....pi^(ni)

其中p1,p2,...pi为素数。

那么，K有那些因子呢？

其实可以考虑任一个因子，他可能是从n1个p1中选若干个（0个到n1个)，从n2个p2中选若干个。。。。。（当全是0个的时候，这个特殊的因子是1）

这样，根据乘法原理，总共有L(K)=(n1+1)*(n2+1)*(n3+1).....

比如，12=2^2*3

一种有3*2=6个因子，他们是1,2,3,4,6,12.



现在考虑要使L(K)为奇数，那么n1,n2,n3不能有一个是奇数，或则，有一个ni+1为偶数，而偶数与任何数相乘仍为偶数。

从而，n1,n2,n3都为偶数,都能被2除。

因为n1,n2,n3都为偶数，显然该数必须是个平方数，可写成K=(X)^2.

从而，1，4，9，16，25，36，49，64，81，100最后是亮的。

DoubleH 2008-03-05 15:00 发表评论

伸展树与半伸展树Java实现

DoubleH — Tue, 18 Dec 2007 16:39:00 GMT

摘要: 伸展树与半伸展树属于自组织的数据结构，能按访问频率调整节点的位置调整一般通过如下方式： 1）绕根的单旋转，跟AVL的单旋转类似 2）一字型旋转(ZigZig Rotation) 3)之字形旋转(ZigZag Rotation) 旋转操作较简单，有点点繁琐。半伸展树不做完全的一字型旋转，它只让父节点绕祖父节点做单旋转。不管怎样，每次访问(插入/查找，删除时展开被删除父节... 阅读全文

DoubleH 2007-12-19 00:39 发表评论

一种新的AVL平衡树删除操作的实现

DoubleH — Tue, 18 Dec 2007 10:30:00 GMT

摘要: AVL树的是一种平衡的二叉搜索树。每次插入，删除的时候需要一个局部的平衡化操作。实现AVL树的插入操作一般不是很难，清楚的理解了平衡因子以及旋转操作实现起来就没多大问题了。难点一般在于删除操作的实现，教科书上一般用很大的篇幅来详细说明各种情况，看起来很凌乱，理解起来很是费劲。考虑到可以把删除操作看成插入操作的逆操作，这里我给出另一种较为清晰的实现方式： 1）删除的时候做一个标记的过程 ... 阅读全文

DoubleH 2007-12-18 18:30 发表评论

使用赢者树的外部排序

DoubleH — Sun, 16 Dec 2007 00:08:00 GMT

外部排序实现使用堆来生成若干个顺串，然后使用多路归并算法来生成最终排序好的内容。

本来打算使用败者树，结果发现败者树当参与的竞赛者相对较多的情况下，没有全部完成就被空节点充满了。
这个按照它的严格算法，其实也是可以知道不能保证总是能排完的。天快亮了，才彻底放弃使用败者树。改成实现赢者树，结果发现赢者树能保证不出错，实现竟也顺手。

最后整了个测试文件500M的随机内容，2~3分钟排序完成了（应该还可以优化），感觉还行。

代码较多，最要考虑到以后可能要重用。

package algorithms.extsort;

import java.io.IOException;

import algorithms.MinHeap;

/**
* @author yovn
*
*/
public class ExternalSorter {



    public void sort(int heapSize,RecordStore source,RunAcceptor mediator ,ResultAcceptor ra)throws IOException
    {
        MinHeap<Record> heap=new MinHeap<Record>(Record.class,heapSize);
        for(int i=0;i<heapSize;i++)
        {
            Record r=source.readNextRecord();
            if(r.isNull())break;
            heap.insert(r);
        }

        Record readR=source.readNextRecord();
        while(!readR.isNull()||!heap.isEmpty())
        {

            Record curR=null;
            //begin output one run
            mediator.startNewRun();
            while(!heap.isEmpty())
            {
                curR=heap.removeMin();

                mediator.acceptRecord(curR);

                if (!readR.isNull()) {
                    if (readR.compareTo(curR) < 0) {
                        heap.addToTail(readR);
                    } else
                        heap.insert(readR);
                }
                readR=source.readNextRecord();

            }
            //done one run
            mediator.closeRun();

            //prepare for next run
            heap.reverse();
            while(!heap.isFull()&&!readR.isNull())
            {

                heap.insert(readR);
                readR=source.readNextRecord();

            }


        }
        RecordStore[] stores=mediator.getProductedStores();
//        LoserTree  lt=new LoserTree(stores);
        WinnerTree  lt=new WinnerTree(stores);

        Record least=lt.nextLeastRecord();
        ra.start();
        while(!least.isNull())
        {
            ra.acceptRecord(least);
            least=lt.nextLeastRecord();
        }
        ra.end();

        for(int i=0;i<stores.length;i++)
        {
            stores[i].destroy();
        }
    }


    public static void main(String[] args) throws IOException
    {
//        RecordStore store=new MemRecordStore(60004,true);
//        RunAcceptor mediator=new MemRunAcceptor();
//        ResultAcceptor ra=new MemResultAcceptor();
        ExternalSorter sorter=new ExternalSorter();

        RecordStore store=new FileRecordStore("test_sort.txt");
        RunAcceptor mediator=new FileRunAcceptor("test_sort");
        ResultAcceptor ra=new FileRecordStore("test_sorted.txt");


        sorter.sort(70000, store, mediator, ra);
    }

}

其余的都打包在此！

源码

DoubleH 2007-12-16 08:08 发表评论

图及其算法复习（Java实现) 三：最小支撑树（Prim,Kruskal算法）

DoubleH — Fri, 14 Dec 2007 15:48:00 GMT

六。最小支撑树MST
给定一个简单有向图，要求权值最小的生成树，即求最小支撑树问题。
所谓生成树，就是说树的顶点集合等于给定图的顶点集合，且边集合包含于图的边集合。
也就说找出构成树的，经过所有顶点的，且权值最小的边集。
树的定义是要求无回路的，然后是要求连通的。

有两个比较经典的算法是：
1）Prim算法：该算法的思想跟Dijstra算法非常相似，Dijstra算法中每次求出下一个顶点时依据的是离初始顶点最近的，而Prim算法则找离V1整个集合最近的，也就是从V1中某个节点出发到该顶点的边的权值最小。
其原理也是每次找局部最优，最后构成全局最优。
实现如下

@Override
    public Edge[] prim() {
        MinHeap<Edge> heap=new MinHeap<Edge>(Edge.class,numEdges);
        Edge[] edges=new Edge[numVertexes-1];
        //we start from 0
        int num=0;//record already how many edges;
        int startV=0;
        Arrays.fill(visitTags, false);
        Edge e;
        for(e=firstEdge(startV);isEdge(e);e=nextEdge(e))
        {
            heap.insert(e);
        }
        visitTags[startV]=true;

        while(num<numVertexes-1&&!heap.isEmpty())//tree's edge number was n-1
        {

            e=heap.removeMin();

            startV=toVertex(e);
            if(visitTags[startV])
            {
                continue;
            }
            visitTags[startV]=true;
            edges[num++]=e;
            for(e=firstEdge(startV);isEdge(e);e=nextEdge(e))
            {
                if(!visitTags[toVertex(e)])//can't add already visit vertex, this may cause cycle
                heap.insert(e);
            }



        }
        if(num<numVertexes-1)
        {
            throw new IllegalArgumentException("not connected graph");
        }
        return edges;
    }

/**
     * A Graph example
     * we mark the vertexes  with 0,1,2,.14 from left to right , up to down
     * S-8-B-4-A-2-C-7-D
     * |   |   |   |   |
     * 3   3   1   2   5
     * |   |   |   |   |
     * E-2-F-6-G-7-H-2-I
     * |   |   |   |   |
     * 6   1   1   1   2
     * |   |   |   |   |
     * J-5-K-1-L-3-M-3-T
     *
     */
    public static void testPrimMST() {



        DefaultGraph g=new DefaultGraph(15);
        g.setEdge(0, 1, 8);
        g.setEdge(1, 0, 8);//its a undirected graph
        g.setEdge(1, 2, 4);
        g.setEdge(2, 1, 4);
        g.setEdge(2, 3, 2);
        g.setEdge(3, 2, 2);
        g.setEdge(3, 4, 7);
        g.setEdge(4, 3, 7);

        g.setEdge(0, 5, 3);
        g.setEdge(5, 0, 3);
        g.setEdge(1, 6, 3);
        g.setEdge(6, 1, 3);
        g.setEdge(2, 7, 1);
        g.setEdge(7, 2, 1);
        g.setEdge(3, 8, 2);
        g.setEdge(8, 3, 2);
        g.setEdge(4, 9, 5);
        g.setEdge(9, 4, 5);


        g.setEdge(5, 6, 2);
        g.setEdge(6, 5, 2);
        g.setEdge(6, 7, 6);
        g.setEdge(7, 6, 6);
        g.setEdge(7, 8, 7);
        g.setEdge(8, 7, 7);
        g.setEdge(8, 9, 2);
        g.setEdge(9, 8, 2);


        g.setEdge(10, 5, 6);
        g.setEdge(5, 10, 6);
        g.setEdge(11, 6, 1);
        g.setEdge(6, 11, 1);
        g.setEdge(12, 7, 1);
        g.setEdge(7, 12, 1);
        g.setEdge(13, 8, 1);
        g.setEdge(8, 13, 1);
        g.setEdge(14, 9, 2);
        g.setEdge(9, 14, 2);

        g.setEdge(10, 11, 5);
        g.setEdge(11, 10, 5);
        g.setEdge(11, 12, 1);
        g.setEdge(12, 11, 1);
        g.setEdge(12, 13, 3);
        g.setEdge(13, 12, 3);
        g.setEdge(13, 14, 3);
        g.setEdge(14, 13, 3);

        g.assignLabels(new String[]{"S","B","A","C","D","E","F","G","H","I","J","K","L","M","T"});
        Edge[] edges=g.prim();
        int total=0;
        for(int i=0;i<edges.length;i++)
        {
            System.out.println(edges[i].toString(g));
            total+=edges[i].getWeight();
        }
        System.out.println("MST total cost:"+total);
}

2)Kruskal算法：
该算法开始把，每个节点看成一个独立的两两不同的等价类，每次去权值最小的边，如果关联这条边的两个顶点在同一个等价类里那么这条边不能放入MST（最小生成树）中，否则放入MST中，并把这两个等价类合并成一个等价类。
继续从剩余边集里选最小的边，直到最后剩余一个等价类了。
该算法涉及等价类的合并/查找,一般用父指针树来实现。下面先给出父指针树实现的并查算法。
带路径压缩的算法，其查找时间代价可以看做是常数的。

package algorithms;

/**
* @author yovn
*
*/
public class ParentTree {


    private static class PTreeNode
    {
        int parentIndex=-1;
        int numChildren=0;//only make sense in root

        void setParent(int i) {

            parentIndex=i;

        }
    }
    PTreeNode[] nodes;
    int numPartions;
    public ParentTree(int numNodes)
    {
        nodes=new PTreeNode[numNodes];
        numPartions=numNodes;
        for(int i=0;i<numNodes;i++)
        {
            nodes[i]=new PTreeNode();
            nodes[i].parentIndex=-1;//means root

        }

    }

    /**
     * use path compress
     * @param i
     * @return
     */
    public int find(int i)
    {
        if(nodes[i].parentIndex==-1)
        {
            return i;
        }
        else
        {
            nodes[i].setParent(find(nodes[i].parentIndex));//compress the path
            return nodes[i].parentIndex;
        }
    }

    public int numPartions()
    {
        return numPartions;
    }
    public boolean union(int i,int j)
    {
        int pi=find(i);
        int pj=find(j);
        if(pi!=pj)
        {
            if(nodes[pi].numChildren>nodes[pj].numChildren)
            {
                nodes[pj].setParent(pi);
                nodes[pj].numChildren+=nodes[pi].numChildren;
                nodes[pi].numChildren=0;

            }
            else
            {
                nodes[pi].setParent(pj);
                nodes[pi].numChildren+=nodes[pj].numChildren;
                nodes[pj].numChildren=0;
            }
            numPartions--;
            return true;
        }
        return false;
    }

}

从边集里权最小的边，我们又可以借助最小值堆来完成。有了父指针树以及最小值堆，现实Kruskal算法就很简单了：

@Override
    public Edge[] kruskal() {
        Edge[] edges=new Edge[numVertexes-1];
        ParentTree ptree=new ParentTree(numVertexes);
        MinHeap<Edge> heap=new MinHeap<Edge>(Edge.class,numEdges);
        for(int i=0;i<numVertexes;i++)
        {
            for(Edge e=firstEdge(i);isEdge(e);e=nextEdge(e))
            {
                heap.insert(e);
            }
        }
        int index=0;
        while(ptree.numPartions()>1)
        {
            Edge e=heap.removeMin();
            if(ptree.union(fromVertex(e),toVertex(e)))
            {
                edges[index++]=e;
            }
        }
        if(index<numVertexes-1)
        {
            throw new IllegalArgumentException("Not a connected graph");
        }
        return edges;

    }

OK，到此，图论的大概的算法算是复习完了。

DoubleH 2007-12-14 23:48 发表评论

图及其算法复习（Java实现) 二：拓扑排序，最短路径问题

DoubleH — Fri, 14 Dec 2007 13:00:00 GMT

摘要: 四拓扑排序考虑一个任务安排的例子，比如有很多任务T1,T2,.... 这些任务又是相互关联的，比如Tj完成前必须要求Ti已完成，这样T1,T2....序列关于这样的先决条件构成一个图，其中如果Ti必须要先于Tj完成，那么就是该图中的一条路径，路径长度为1的就是一条边。拓扑排序就是把这些任务按照完成的先后顺序排列出来。显然，这样的顺序可能不是唯一的，比如Tk，T... 阅读全文

DoubleH 2007-12-14 21:00 发表评论

图及其算法复习（Java实现) 一：存储结构，深度优先周游，广度优先周游

DoubleH — Fri, 14 Dec 2007 06:46:00 GMT

摘要: 很早就想总结一下了，一直没有时间，OK，进入正题。一图的基本概念及存储结构图G是由顶点的有穷集合，以及顶点之间的关系组成，顶点的集合记为V，顶点之间的关系构成边的集合E G=(V,E). 说一条边从v1,连接到v2,那么有v1Ev2(E是V上的一个关系）《=》∈E. 图有有向图，无向图之分，无向图的一条边相当于有向图的中两条边，即如果无向图... 阅读全文

DoubleH 2007-12-14 14:46 发表评论

排序算法复习（Java实现）(二）：归并排序，堆排序，桶式排序，基数排序

DoubleH — Thu, 13 Dec 2007 17:03:00 GMT

摘要: 六归并排序算法思想是每次把待排序列分成两部分，分别对这两部分递归地用归并排序，完成后把这两个子部分合并成一个序列。归并排序借助一个全局性临时数组来方便对子序列的归并，该算法核心在于归并。 Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.c... 阅读全文

DoubleH 2007-12-14 01:03 发表评论

排序算法复习（Java实现）(一）：插入，冒泡，选择，Shell,快速排序

DoubleH — Wed, 12 Dec 2007 17:08:00 GMT

为了便于管理，先引入个基础类：

package algorithms;

/**
* @author yovn
*
*/
public abstract class Sorter<E extends Comparable<E>> {

    public abstract void sort(E[] array,int from ,int len);

    public final void sort(E[] array)
    {
        sort(array,0,array.length);
    }
    protected final void swap(E[] array,int from ,int to)
    {
        E tmp=array[from];
        array[from]=array[to];
        array[to]=tmp;
    }

}

一插入排序
该算法在数据规模小的时候十分高效，该算法每次插入第K+1到前K个有序数组中一个合适位置，K从0开始到N-1,从而完成排序：

package algorithms;
/**
* @author yovn
*/
public class InsertSorter<E extends Comparable<E>> extends Sorter<E> {

    /* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    public void sort(E[] array, int from, int len) {
         E tmp=null;
          for(int i=from+1;i<from+len;i++)
          {
              tmp=array[i];
              int j=i;
              for(;j>from;j--)
              {
                  if(tmp.compareTo(array[j-1])<0)
                  {
                      array[j]=array[j-1];
                  }
                  else break;
              }
              array[j]=tmp;
          }
    }



}

二冒泡排序
这可能是最简单的排序算法了，算法思想是每次从数组末端开始比较相邻两元素，把第i小的冒泡到数组的第i个位置。i从0一直到N-1从而完成排序。（当然也可以从数组开始端开始比较相邻两元素，把第i大的冒泡到数组的第N-i个位置。i从0一直到N-1从而完成排序。)

package algorithms;

/**
* @author yovn
*
*/
public class BubbleSorter<E extends Comparable<E>> extends Sorter<E> {

    private static  boolean DWON=true;

    public final void bubble_down(E[] array, int from, int len)
    {
        for(int i=from;i<from+len;i++)
        {
            for(int j=from+len-1;j>i;j--)
            {
                if(array[j].compareTo(array[j-1])<0)
                {
                    swap(array,j-1,j);
                }
            }
        }
    }

    public final void bubble_up(E[] array, int from, int len)
    {
        for(int i=from+len-1;i>=from;i--)
        {
            for(int j=from;j<i;j++)
            {
                if(array[j].compareTo(array[j+1])>0)
                {
                    swap(array,j,j+1);
                }
            }
        }
    }
    @Override
    public void sort(E[] array, int from, int len) {

        if(DWON)
        {
            bubble_down(array,from,len);
        }
        else
        {
            bubble_up(array,from,len);
        }
    }

}

三，选择排序
选择排序相对于冒泡来说，它不是每次发现逆序都交换，而是在找到全局第i小的时候记下该元素位置，最后跟第i个元素交换，从而保证数组最终的有序。
相对与插入排序来说，选择排序每次选出的都是全局第i小的，不会调整前i个元素了。

package algorithms;
/**
* @author yovn
*
*/
public class SelectSorter<E extends Comparable<E>> extends Sorter<E> {

    /* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {
        for(int i=0;i<len;i++)
        {
            int smallest=i;
            int j=i+from;
            for(;j<from+len;j++)
            {
                if(array[j].compareTo(array[smallest])<0)
                {
                    smallest=j;
                }
            }
            swap(array,i,smallest);

        }

    }

}

四 Shell排序
Shell排序可以理解为插入排序的变种，它充分利用了插入排序的两个特点：
1）当数据规模小的时候非常高效
2）当给定数据已经有序时的时间代价为O(N)
所以，Shell排序每次把数据分成若个小块，来使用插入排序，而且之后在这若个小块排好序的情况下把它们合成大一点的小块，继续使用插入排序，不停的合并小块，知道最后成一个块，并使用插入排序。

这里每次分成若干小块是通过“增量” 来控制的，开始时增量交大，接近N/2,从而使得分割出来接近N/2个小块，逐渐的减小“增量“最终到减小到1。

一直较好的增量序列是2^k-1,2^(k-1)-1,.....7,3,1,这样可使Shell排序时间复杂度达到O(N^1.5)
所以我在实现Shell排序的时候采用该增量序列

package algorithms;

/**
* @author yovn
*/
public class ShellSorter<E extends Comparable<E>> extends Sorter<E>  {

    /* (non-Javadoc)
     * Our delta value choose 2^k-1,2^(k-1)-1,.7,3,1.
     * complexity is O(n^1.5)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {

        //1.calculate  the first delta value;
        int value=1;
        while((value+1)*2<len)
        {
            value=(value+1)*2-1;

        }

        for(int delta=value;delta>=1;delta=(delta+1)/2-1)
        {
            for(int i=0;i<delta;i++)
            {
                modify_insert_sort(array,from+i,len-i,delta);
            }
        }

    }

    private final  void modify_insert_sort(E[] array, int from, int len,int delta) {
          if(len<=1)return;
          E tmp=null;
          for(int i=from+delta;i<from+len;i+=delta)
          {
              tmp=array[i];
              int j=i;
              for(;j>from;j-=delta)
              {
                  if(tmp.compareTo(array[j-delta])<0)
                  {
                      array[j]=array[j-delta];
                  }
                  else break;
              }
              array[j]=tmp;
          }

    }
}

五快速排序
快速排序是目前使用可能最广泛的排序算法了。
一般分如下步骤：
1）选择一个枢纽元素（有很对选法，我的实现里采用去中间元素的简单方法）
2）使用该枢纽元素分割数组，使得比该元素小的元素在它的左边，比它大的在右边。并把枢纽元素放在合适的位置。
3）根据枢纽元素最后确定的位置，把数组分成三部分，左边的，右边的，枢纽元素自己，对左边的，右边的分别递归调用快速排序算法即可。
快速排序的核心在于分割算法，也可以说是最有技巧的部分。

package algorithms;

/**
* @author yovn
*
*/
public class QuickSorter<E extends Comparable<E>> extends Sorter<E> {

    /* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {
        q_sort(array,from,from+len-1);
    }


    private final void q_sort(E[] array, int from, int to) {
        if(to-from<1)return;
        int pivot=selectPivot(array,from,to);



        pivot=partion(array,from,to,pivot);

        q_sort(array,from,pivot-1);
        q_sort(array,pivot+1,to);

    }

    private int partion(E[] array, int from, int to, int pivot) {
        E tmp=array[pivot];
        array[pivot]=array[to];//now to's position is available

        while(from!=to)
        {
            while(from<to&&array[from].compareTo(tmp)<=0)from++;
            if(from<to)
            {
                array[to]=array[from];//now from's position is available
                to--;
            }
            while(from<to&&array[to].compareTo(tmp)>=0)to--;
            if(from<to)
            {
                array[from]=array[to];//now to's position is available now
                from++;
            }
        }
        array[from]=tmp;
        return from;
    }

    private int selectPivot(E[] array, int from, int to) {

        return (from+to)/2;
    }

}

还有归并排序，堆排序，桶式排序，基数排序，下次在归纳。

DoubleH 2007-12-13 01:08 发表评论