色欲aⅴ亚洲情无码AV,亚洲av永久无码天堂网,无码久久精品国产亚洲Av影片

求连�l�正整数使得其和为给定的一个正整数的构造性解�?

DoubleH — Thu, 01 Dec 2011 14:09:00 GMT

如题�Q�求�q�箋正整��C��得其和�ؓ�l�定的一个正整数

下面�l�出我的解法�Q�几乎可以一步到位求出来

实现代码如下�Q?br />

/**
*Author: Koth (http://weibo.com/yovn)
*Date:  2011-12-01
*/
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

int solve(int Y,int& X){
    int m=0;
    int t=Y;
    if(Y<=0){
        X=Y;
        return 1;
    }
    while((t&1)==0){
        m+=1;
        t=t>>1;
    }
    if(m==32){
        X=Y;
        return 1;
    }
    int lastK=32;
    for(;lastK>m+1;lastK--){
        if(Y &(1<<(lastK-1))){

            break;
        }

    }

    //its a number st. exp(2,K)
    if(lastK==(m+1)){
        X=Y;
        return 1;
    }
    int k=1<<(m+1);
    int b=(Y>>m)-(1<<(lastK-m-1));

    X=(1<<(lastK-m-2))+(b+1-k)/2;

    if(X<=0){
        k=k-1-((0-X)<<1);
        X=0-X+1;
    }

    return k;

}

int main(int argc,char* argv[]){
    if(argc<=1){
        fprintf(stdout,"Usage:%s number\n",argv[0]);
        return 0;
    }
    int Y=atoi(argv[1]);
    int X=0;
    int k=solve(Y,X);
    fprintf(stdout,"%d=",Y);
    for(int i=0;i<k;i++){
        fprintf(stdout,"%d",X+i);
        if(i<(k-1)){
            fprintf(stdout,"+");
        }
    }
    fprintf(stdout,"\n");
    return 0;
}

DoubleH 2011-12-01 22:09 发表评论

DP的几道练手题

DoubleH — Sun, 06 Feb 2011 13:13:00 GMT

摘要: �q�过的差不多了，今天偶尔兴�v上HOJ上翻几道DP�l�手的题来。。。，��Z��把代码脓下留�?nbsp; 1.数塔 Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ -->/** * */ pack... 阅读全文

DoubleH 2011-02-06 21:13 发表评论

DoubleH — Fri, 04 Dec 2009 09:57:00 GMT

摘要: 前一��博客，我简单提了下怎么为NIO2增加TransmitFile支持�Q�文件传送吞吐量是一个性能��x��点，此外�Q��ƈ发连接数也是重要的关注点�? 不过JDK7中又一�ơ做了简单的实现�Q�不支持同时投递多个AcceptEx��h��Q�只支持一�ơ一个，�q�回后再投递。这��P��客户端连接的接受速度必然大打折扣。不知道��Z��么sun会做�q�样的实玎ͼ�WSASend()/WSAReceive()一�ơ只允许一个还是可以理解，... 阅读全文

DoubleH 2009-12-04 17:57 发表评论

JDK7 NIO2 实践: 增加 TransmitFile支持

DoubleH — Sun, 29 Nov 2009 07:19:00 GMT

JDK7的NIO2�Ҏ��或许是我最期待的，我一直想��Z��它写一个高性能的Java Http Server.现在�q�个��x��l�于可以实施了�?br /> 本�h��Z��目前最新的JDK7 b76开发了一个HTTP Server性能��实不错�?br /> 在windows�q�_��上NIO2采用AccpetEx来异步接受连接，�q�且��d��全都兌��到IOCP完成端口。不仅如此，��Z��方便开发者��用，�q�IOCP工作�U�程都封装好了，你只要提供线�E�池��OK�?br />
但是要注意，IOCP工作�U�程的线�E�池必须�?Fix的，因�ؓ你发出的��d��h��都关联到相应的线�E�上�Q�如果线�E�死了，那读写完成情冉|��不知道的�?br />
作�ؓ一个Http Server�Q�传送文件是必不可少的功能，那一般文件的传送都是要把程序里的buffer拯��到内核的buffer�Q�由内核发送出�ȝ��。windows�q�_��上�ؓ�q�种情况提供了很好的解决�Ҏ��Q��用TransmitFile接口

BOOL TransmitFile(
    SOCKET hSocket,
    HANDLE hFile,
    DWORD nNumberOfBytesToWrite,
    DWORD nNumberOfBytesPerSend,
    LPOVERLAPPED lpOverlapped,
    LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
    DWORD dwFlags
);

你只要把文�g句柄发送给内核��p��了，内核帮你搞定其余的，真正做到Zero-Copy.
但是很不�q�，NIO2里AsynchronousSocketChannel没有提供�q�样的支持。而�ؓHTTP Server的性能考量�Q�本人只好自己增加这个支持�?br />
要无�~�支持，�q�个必须得表现的�?Read /Write一��P��有完成的通知�Q�通知传送多��数据，�{�等�?br />
仔细��d��sun的IOCP实现以后发现�q�部分工作他们封装得很好�Q�基本只要往他们的框枉��加东西就好了�?br /> ��Z��能访问他们的框架代码�Q�我定义自己的TransmitFile支持�c�d��sun.nio.ch包里�Q�以获得最大的权限�?br />

package sun.nio.ch;

import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.channels.AsynchronousCloseException;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.CompletionHandler;
import java.nio.channels.NotYetConnectedException;
import java.nio.channels.WritePendingException;
import java.util.concurrent.Future;

/**
* @author Yvon
*
*/
public class WindowsTransmitFileSupport {

   //Sun's NIO2 channel implementation class
    private WindowsAsynchronousSocketChannelImpl channel;

    //nio2 framework core data structure
    PendingIoCache ioCache;

   //some field retrieve from sun channel implementation class
    private Object writeLock;
    private Field writingF;
    private Field writeShutdownF;
    private Field writeKilledF; // f

    WindowsTransmitFileSupport()
    {
        //dummy one for JNI code
    }

    /**
     *
     */
    public WindowsTransmitFileSupport(
            AsynchronousSocketChannel
             channel) {

        this.channel = (WindowsAsynchronousSocketChannelImpl)channel;
        try {
        // Initialize the fields
            Field f = WindowsAsynchronousSocketChannelImpl.class
                    .getDeclaredField("ioCache");
            f.setAccessible(true);
            ioCache = (PendingIoCache) f.get(channel);
            f = AsynchronousSocketChannelImpl.class
                    .getDeclaredField("writeLock");
            f.setAccessible(true);
            writeLock = f.get(channel);
            writingF = AsynchronousSocketChannelImpl.class
                    .getDeclaredField("writing");
            writingF.setAccessible(true);

            writeShutdownF = AsynchronousSocketChannelImpl.class
                    .getDeclaredField("writeShutdown");
            writeShutdownF.setAccessible(true);

            writeKilledF = AsynchronousSocketChannelImpl.class
                    .getDeclaredField("writeKilled");
            writeKilledF.setAccessible(true);

        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    /**
     * Implements the task to initiate a write and the handler to consume the
     * result when the send file completes.
     */
    private class SendFileTask<V, A> implements Runnable, Iocp.ResultHandler {
        private final PendingFuture<V, A> result;
        private final long file;//file is windows file HANDLE

        SendFileTask(long file, PendingFuture<V, A> result) {
            this.result = result;
            this.file = file;
        }



        @Override
        // @SuppressWarnings("unchecked")
        public void run() {
            long overlapped = 0L;
            boolean pending = false;
            boolean shutdown = false;

            try {
                channel.begin();



                // get an OVERLAPPED structure (from the cache or allocate)
                overlapped = ioCache.add(result);
                int n = transmitFile0(channel.handle, file, overlapped);
                if (n == IOStatus.UNAVAILABLE) {
                    // I/O is pending
                    pending = true;
                    return;
                }
                if (n == IOStatus.EOF) {
                    // special case for shutdown output
                    shutdown = true;
                    throw new ClosedChannelException();
                }
                // write completed immediately
                throw new InternalError("Write completed immediately");
            } catch (Throwable x) {
                // write failed. Enable writing before releasing waiters.
                channel.enableWriting();
                if (!shutdown && (x instanceof ClosedChannelException))
                    x = new AsynchronousCloseException();
                if (!(x instanceof IOException))
                    x = new IOException(x);
                result.setFailure(x);
            } finally {
                // release resources if I/O not pending
                if (!pending) {
                    if (overlapped != 0L)
                        ioCache.remove(overlapped);

                }
                channel.end();
            }

            // invoke completion handler
            Invoker.invoke(result);
        }



        /**
         * Executed when the I/O has completed
         */
        @Override
        @SuppressWarnings("unchecked")
        public void completed(int bytesTransferred, boolean canInvokeDirect) {


            // release waiters if not already released by timeout
            synchronized (result) {
                if (result.isDone())
                    return;
                channel.enableWriting();

                result.setResult((V) Integer.valueOf(bytesTransferred));

            }
            if (canInvokeDirect) {
                Invoker.invokeUnchecked(result);
            } else {
                Invoker.invoke(result);
            }
        }

        @Override
        public void failed(int error, IOException x) {
            // return direct buffer to cache if substituted


            // release waiters if not already released by timeout
            if (!channel.isOpen())
                x = new AsynchronousCloseException();

            synchronized (result) {
                if (result.isDone())
                    return;
                channel.enableWriting();
                result.setFailure(x);
            }
            Invoker.invoke(result);
        }

    }

    public <V extends Number, A> Future<V> sendFile(long file, A att,
            CompletionHandler<V, ? super A> handler) {

        boolean closed = false;
        if (channel.isOpen()) {
            if (channel.remoteAddress == null)
                throw new NotYetConnectedException();


            // check and update state
            synchronized (writeLock) {
                try{
                if (writeKilledF.getBoolean(channel))
                    throw new IllegalStateException(
                            "Writing not allowed due to timeout or cancellation");
                if (writingF.getBoolean(channel))
                    throw new WritePendingException();
                if (writeShutdownF.getBoolean(channel)) {
                    closed = true;
                } else {
                    writingF.setBoolean(channel, true);
                }
                }catch(Exception e)
                {
                    IllegalStateException ise=new IllegalStateException(" catch exception when write");
                    ise.initCause(e);
                    throw ise;
                }
            }
        } else {
            closed = true;
        }

        // channel is closed or shutdown for write
        if (closed) {
            Throwable e = new ClosedChannelException();
            if (handler == null)
                return CompletedFuture.withFailure(e);
            Invoker.invoke(channel, handler, att, null, e);
            return null;
        }

        return implSendFile(file,att,handler);
    }

    <V extends Number, A> Future<V> implSendFile(long file, A attachment,
            CompletionHandler<V, ? super A> handler) {
        // setup task
        PendingFuture<V, A> result = new PendingFuture<V, A>(channel, handler,
                attachment);
        SendFileTask<V,A> sendTask=new SendFileTask<V,A>(file,result);
        result.setContext(sendTask);
        // initiate I/O (can only be done from thread in thread pool)
        // initiate I/O
        if (Iocp.supportsThreadAgnosticIo()) {
            sendTask.run();
        } else {
            Invoker.invokeOnThreadInThreadPool(channel, sendTask);
        }
        return result;
    }

    private native int transmitFile0(long handle, long file,
            long overlapped);

}

�q�个操作跟默认实现的里的write操作是很像的�Q�只是最后调用的本地�Ҏ��不一栗��?br />
接下来，我们怎么使用呢，�q�个�c�L��定义在sun的包里的�Q�直接用的话�Q�会报IllegalAccessError,因�ؓ我们的类加蝲器跟初始化加载器是不一��L��?br /> 解决办法一个是通过启动参数-Xbootclasspath�Q�让我们的包被初始加载器加蝲。我个�h不喜�Ƣ这�U�办法，所以就采用JNI来定义我们的windows TransmitFile支持�c�R�?br />
�q�样我们的工作算是完成了�Q�注意，发送文件的时候传得是文�g句柄�Q�这样做的好处是你可以更好的控制�Q�一般是在发送前�Q�打开文�g句柄�Q�完成后在回调通知�Ҏ��里关闭文件句柄�?br />

有兴��的同学可以看看我的HTTP server��目:
http://code.google.com/p/jabhttpd/

目前基本功能实现得差不多�Q�做了些��单的��试�Q�性能比较满意。这个服务器不打��支持servlet api�Q�基本是专门�l�做��Z��长连接模式通信的定做的�?br />

DoubleH 2009-11-29 15:19 发表评论

DoubleH — Mon, 04 May 2009 03:45:00 GMT

问题�Q?br /> 有个链表�Q�List)�Q�有N个元素，当N很大的时候，我们通常惛_��批处理该链表。假如每�ơ处理M�?0
问题很简单，我们需�?lt;N/M>�ơ，�q�里我们�?lt;>表示向上取整,[]表示向下取整�Q�那么怎么来表�C��个值呢�Q?br /> 我们可以证明�Q?br /> =[(N-1)/M]+1 (0
不失一般性，我们设N=Mk+r(0<=r 1�Q�当r>0�Ӟ��

左边�Q?lt;N/M>=<(Mk+r)/M>==k+=k+1
双��Q�[(N-1)/M]+1=[(Mk+r-1)/M]+1=[k+(r-1)/M]+1=k+1+[(r-1)/M]=k+1
2�Q�当r=0
左边�Q?lt;N/M>=k
双��Q�[(N-1)/M]+1=[(Mk-1)/M]+1=[(M(k-1)+M-1)/M]+1=[k-1+(M-1)/M]+1=k+[(M-1)/M]=k

命题得证�?br />
有了�q�个公式�Q�我们在Java代码里可以这栯��?

int nn=(N-1)/M +1
.

因�ؓ'/'是往下取整的�?br />

DoubleH 2009-05-04 11:45 发表评论

POJ 3164 最��树形图��法

DoubleH — Fri, 24 Apr 2009 08:39:00 GMT

原题�Q?br />
Command Network

Description

After a long lasting war on words, a war on arms finally breaks out between littleken’s and KnuthOcean’s kingdoms. A sudden and violent assault by KnuthOcean’s force has rendered a total failure of littleken’s command network. A provisional network must be built immediately. littleken orders snoopy to take charge of the project.

With the situation studied to every detail, snoopy believes that the most urgent point is to enable littenken’s commands to reach every disconnected node in the destroyed network and decides on a plan to build a unidirectional communication network. The nodes are distributed on a plane. If littleken’s commands are to be able to be delivered directly from a node A to another node B, a wire will have to be built along the straight line segment connecting the two nodes. Since it’s in wartime, not between all pairs of nodes can wires be built. snoopy wants the plan to require the shortest total length of wires so that the construction can be done very soon.

Input

The input contains several test cases. Each test case starts with a line containing two integer N (N ≤ 100), the number of nodes in the destroyed network, and M (M ≤ 10⁴), the number of pairs of nodes between which a wire can be built. The next N lines each contain an ordered pair x_i and y_i, giving the Cartesian coordinates of the nodes. Then follow M lines each containing two integers i and j between 1 and N (inclusive) meaning a wire can be built between node i and node j for unidirectional command delivery from the former to the latter. littleken’s headquarter is always located at node 1. Process to end of file.

Output

For each test case, output exactly one line containing the shortest total length of wires to two digits past the decimal point. In the cases that such a network does not exist, just output ‘poor snoopy’.

一开始没仔细读题�Q�一看以为是最��生成树呢，�l�果Krusal��法上去WA了，Prim��法也WA,修修�Ҏ��一直WA�Q�第二天发现本题是要在有向图上面构造最��树形图�?br />
按照著名的Zhu-Liu��法�Q�仔�l�实��C��一边，�l�于AC了�?br /> 按照我的理解�ȝ��下该��法�Q�该��法�Ҏ��个结点，除根节点外寻找最��入边，
1�Q�如果这些入边不构成环，那么�Ҏ��证明�q�些�Ҏ��成最��树形图�?br /> 证明�Q�设加上根节点r一共N个点�Q�那么一共有N-1条边�Q�证明从r能到每个点，若存在一点v�Q��得从r到v没有路径�Q�那么，假设从v反向回退必然构成环，因�ؓ每个炚w��了r都有入边�Q�如果不构成环，该�\径可以无�I�大�?br /> 2�Q�如果存在环�Q�我们把环收�~�成一个点�Q�更新相应的入边和出边，得到新的图G',使得原问题在G'中等效：
怎么收羃呢？
假设我们把环收羃成环上的��L��一点v�Q�所有进环的边和出环的边自动变成v的边�Q�如果已有，取长度最短的�Q�，其余�Ҏ��Cؓ删除�Q�更��C��在环上的所有点�q�入该环的长度cost为cost-cost(prev[x],x);其中点x��入环的边在环上的端点。出边保持不变�?br />
�q�里��Z��么这么更斎ͼ�因�ؓ�q�样更新使得我们的算法在新图上是�{�效的。�Q何环的解军_��意味着在新��N��面得为改收羃后的点寻找新的入边，而实际的��p��应该是新的入边减��d��有的入边长度�Q�我们的��法在找到环的时候就把环上所有的边的长度计算在花费内�?而对��是没有媄响的�?br />

到这��法的框架基本出来了。当为某�Ҏ��扑ֈ�入边的时候，意味着无解。�ؓ了加快无解的侦测�Q�我们先�q�行一遍DFS搜烦�Q�假如从根节点出发，可触及的节点数小于N-1(不含r)则意味着无解。反之，肯定有解�?
��Z��么？
因�ؓ如果可触及数��于N-1,意味着某点是不可触及的�Q�也��是原图不是��p��通。对该点来说不存在从r到它的�\径。反之，从r到某炚w��有一条�\径，沿着该�\径就能找到结点的入边�?br />

�W�二个问题是�Q�如何快速侦��环呢？
我��用了一个不�怺�集。回忆Krusal的算法实现里面也是��用不�怺�集来避免找��生环的最��边�?br />
下面是我的代码：

// 3164.cpp : Defines the entry point for the console application.
//

#include <iostream>
#include <cmath>

using namespace std;

typedef struct _Point
{

    double x;
    double y;

    double distanceTo(const struct _Point& r)
    {
          return sqrt((x-r.x)*(x-r.x)+(y-r.y)*(y-r.y));

    }

}Point;

const int MAX_V=100;
const int MAX_E=10000;
const double NO_EDGE=1.7976931348623158e+308;

Point vertexes[MAX_V]={0};
int parents[MAX_V]={0};
int ranks[MAX_V]={0};
double G[MAX_V][MAX_V]={0};
bool visited[MAX_V]={0};
bool deleted[MAX_V]={0};
int prev[MAX_V]={0};

int nVertex=0;
int nEdge=0;

int u_find(int a)
{
    if(parents[a]==a)return a;
    parents[a]=u_find(parents[a]);
    return parents[a];
}
void u_union(int a,int b)
{
    int pa=u_find(a);
    int pb=u_find(b);
    if(ranks[pa]==ranks[pb])
    {
        ranks[pa]++;
        parents[pb]=pa;
    }else if(ranks[pa]<ranks[pb])
    {
        parents[pa]=pb;
    }
    else
    {
        parents[pb]=pa;
    }
}

void DFS(int v,int& c)
{

    visited[v]=true;
    for(int i=1;i<nVertex;i++)
    {
        if(!visited[i]&&G[v][i]<NO_EDGE)
        {
            c+=1;

            DFS(i,c);
        }

    }

}

void doCycle(int s,int t,double& cost)
{
    memset(visited,0,sizeof(bool)*nVertex);
    int i=s;
    do
    {
        visited[i]=true;
        cost+=G[prev[i]-1][i];
        //cout<<"from "<<(prev[i]-1)<<" to "<
        i=prev[i]-1;

    }while(i!=s);

    do
    {


        for(int k=0;k<nVertex;k++)
        {
            if(!deleted[k]&&!visited[k])
            {

                if(G[k][i]<NO_EDGE)
                {
                    if(G[k][i]-G[prev[i]-1][i]<G[k][s])
                    {

                        G[k][s]=G[k][i]-G[prev[i]-1][i];
                        //cout<<"1.update ["<
                    }


                }
                if(G[i][k]<NO_EDGE)
                {
                    if(G[i][k]<G[s][k])
                    {

                        G[s][k]=G[i][k];
                        //cout<<"2.update ["<
                    }

                }
            }
        }

        if(i!=s)
        {
            deleted[i]=true;
            //cout<<"mark "<
        }
        i=prev[i]-1;

    }while(i!=s);

}

int main(void)
{


    while(cin>>nVertex>>nEdge)
    {

        int s,t;

        int nv=0;
        bool cycle=0;
        double cost=0;
        memset(vertexes,0,sizeof(vertexes));
        memset(visited,0,sizeof(visited) );

        memset(deleted,0,sizeof(deleted));
        memset(G,0,sizeof(G));
        memset(prev,0,sizeof(prev));

        memset(ranks,0,sizeof(ranks));

        memset(parents,0,sizeof(parents));

        for(int i=0;i<nVertex;i++)
        {

            cin>>vertexes[i].x>>vertexes[i].y;
            parents[i]=i;
            for(int j=0;j<nVertex;j++)
            {
                G[i][j]=NO_EDGE;
            }

        }
        for(int i=0;i<nEdge;i++)
        {

            cin>>s>>t;
            if(t==1||s==t)continue;
            G[s-1][t-1]=vertexes[s-1].distanceTo(vertexes[t-1]);

        }

        DFS(0,nv);
        if(nv<nVertex-1)
        {

            cout<<"poor snoopy"<<endl;
            continue;
        }

        do {
            cycle=false;
            for(int i=0;i<nVertex;i++){parents[i]=i;}
            memset(ranks,0,sizeof(bool)*nVertex);


            for (int i = 1; i < nVertex; i++) {
                double minimum=NO_EDGE;
                if(deleted[i])continue;
                for(int k=0;k<nVertex;k++)
                {
                    if(!deleted[k]&&minimum>G[k][i])
                    {
                        prev[i]=k+1;
                        minimum=G[k][i];
                    }
                }
                if(minimum==NO_EDGE)
                {


                    throw 1;
                }
                if (u_find(prev[i]-1) == u_find(i)) {
                    doCycle(prev[i]-1,i, cost);
                    cycle = true;
                    break;
                }
                else
                {
                    u_union(i,prev[i]-1);
                }

            }

        } while (cycle);

        for (int i = 1; i < nVertex; i++) {
            if(!deleted[i])
            {
                cost+=G[prev[i]-1][i];
                //cout<<"from "<<(prev[i]-1)<<" to "<
            }

        }

        printf("%.2f\n",cost);

    }

}

DoubleH 2009-04-24 16:39 发表评论

《算法概论》第一章习�?5证明�Q�Wilson定理)

DoubleH — Fri, 10 Apr 2009 14:38:00 GMT

   今天��C��本《算法概论》媄印注释版�Q�仔�l�看了第一章，果然名不虚传�Q�很是吸引�h�?br /> �W�一章的习题隑ֺ�适中�Q�这里抽出第35题来�Q�这题是证明Wilson定理�?br /> Wilson定理�Q?br />    N是一个素数当且仅�? (N-1)! ≡ -1(mod N)

证明�Q?br /> 首先我们证明若N是素敎ͼ�那么�{�式成立�Q�对于N=2,�q�是很明昄��。以下证明N>2 的情形�?br /> 1�Q�若N是素敎ͼ�那么关于N同余的乘法群G={1,2,3....N-1}
    ��G每个元素都有逆元�Q�映��?f:a -> a^-1 �Q�f(a)=a^-1 是一个一一映射。现在，��d��一个元素，它的逆元要么是其它一个元素，或者是它本�w��?我们假设其中元素x的逆元是它本��n�Q�那么x*x ≡1(mod N) =>(x+1)*(x-1)=K*N,而N是素敎ͼ�所以要么x=N-1,要么x=1。也��是��_��除了�q�两个元素，其它的元素的逆元都是映射到别的元素的。而N>2,是奇敎ͼ�所以元素共有N-1个，也就是偶��C��元素。这��P��除了1和N-1外剩余的N-3个元素刚好结成两两一�?x,y)(逆元是唯一的）使得f(x)=y=x^-1,也就是xy≡1(mod N).
现在把G的元素全部乘��h��Q�让互�ؓ逆元的元素组成一寚w��?N-1)!=1*(N-1)*(x1*y1)*(x2*y2)...(xk*yk)≡1*(N-1)*1*1...1 (mod N)≡-1(mod N).
    �q�样�Q�我们证明了一个方向了�Q�下面我们证明另一个方�?br />
2�Q�若(N-1)! ≡ -1(mod N)成立�Q�则N是素敎ͼ�若不�Ӟ��?N是和数。则(N-1)!肯定整除N,因�ؓN的每个因子p满��p>1,p    现在�?N-1)!=K1*N.�?N-1)! ≡ -1(mod N) => K1*N ≡ -1(mod N),由同余性质知，存在K2使得K1*N+1=K2*N,两边同时除以N得K1+1/N=K2.昄��Q�这是不可能的，所以若(N-1)! ≡ -1(mod N)成立�Q�则N是素�?br />
证明完毕�Q?br />
�q�里用群的概念能够简化一定的描述�Q�其实可以完全不用群的概�늚��Q�只不过�q�样一来，描述更长点，�J�琐点！

DoubleH 2009-04-10 22:38 发表评论

[��法]09考研数据�l�构试题解法

DoubleH — Sat, 17 Jan 2009 05:56:00 GMT

今天�ȝ��上看了一�?9�q�的考研试题�Q�看见该题目(囄��)�Q?br />

先来定义�l�点�Q��ؓ了简便，省略set/get)�Q?br />

public class Node
{
public int data;
public Node link;
}

我能惛_��的两�U�解法，一个基于递归�Q?

递归版的思�\��是�Q�基于当前结点，如果后一个是倒数�W�K-1,那么当前�l�点是所求，若不�Ӟ��q�回当前是倒数�W�几个�?br />

public int printRKWithRecur(Node head,int k)
    {
        if(k==0||head==null||head.link==null)return 0;
        if(_recurFind(head.link,k)>=k)return 1;
        return 0;
    }
    private final int _recurFind(Node node, int k) {
        if(node.link==null)
        {
            return 1;
        }
        int sRet=_recurFind(node.link,k);
        if(sRet==k-1)
        {
            System.out.println("Got:"+node.data);
            return k;
        }
        return sRet+1;
    }

�Ҏ��个结点，该算法都只访问一�ơ，因此复杂度O(N).

�W�二解法�Q�相寚w��归来说�Q�这�U�方法可以算是消除递归版，而且从某�U�意义上来说比递归更高效，跟省�I�间�Q�递归版实际上是把回溯的数据存在栈上，而版�Ҏ��是自己存储，且利用数�l�实��C��个��@环队列，只存储K个元素�?

public static class CycleIntQueue
    {
        int[] datas;
        int top=0;
        int num=0;
        public CycleIntQueue(int n)
        {
            datas=new int[n];
        }

        public void push(int i)
        {
            datas[(top++)%datas.length]=i;
            num++;

        }
        public int numPushed()
        {
            return num;
        }


        public int getButtom()
        {
            return datas[top%datas.length];
        }
    }
    public int printRKWithCycleQueue(Node head,int k)
    {
        if(k==0||head==null)return 0;
        CycleIntQueue queue=new CycleIntQueue(k);
        Node cur=head.link;
        while(cur!=null)
        {
            queue.push(cur.data);
            cur=cur.link;
        }
        if(queue.numPushed()<k)return 0;

        System.out.println("Got:"+queue.getButtom());
        return 1;
    }

本算法，都每个结点也只放一�ơ，另外�q�行一�ơ入队操作，该操作复杂度O(1),从而，整个��法复杂度仍是O(N).

DoubleH 2009-01-17 13:56 发表评论

DoubleH — Tue, 06 Jan 2009 14:27:00 GMT

�q�日在CSDN上看��C��软一道面试题�Q�挺有意思的�?br /> 题目�Q�一条小溪上7块石��_��如图所�C�：

分别有六只青蛙：A�Q�B�Q�C�Q�D�Q�E�Q�F。A�Q�B�Q�C三只蛙想��d��岸，它们只会从左向右跻I��D�Q�E�Q�F三只蛙想��d��岸，它们只会从右向左跟뀂青蛙每�ơ最多蟩到自己前方第2块石头上。请问最��要跛_��ơ所有青蛙上岸。写出步骤�?br />
�q�个题是个�\径搜索的问题�Q�在解空间搜索所有的解，�q�找出最优的解法�Q�即步骤最��的�Q��?br /> 那么怎么��是一个解呢？具体而言��是最后石头上没有青蛙了�?br />

我们先给题目建模�Q?块石��_��其上可以是没青蛙�Q�可以有一只往左蟩的青蛙，也可以有一只往双��的青蛙。可以把�q?块石头看成一个整体，来表�C�Z��个状态。这里我们把�q?块石头看成一个数�l�，里面只能�?,1,2三种��|��q�样表示�Q�那么初始时为：

1,1,1,0,2,2,2

我们把它再表�C�成一个数字，来表�C�状态��|��q�个值把�q�个数组按三�q�制拼成一个数字，我们用一个辅助函数来做这件事情：

private final int makeS() {

        int r=0;
        int p=1;
        for(int i=0;i<7;i++)
        {
            r+=p*states[i];
            p*=3;
        }
        return r;
    }

那么题目现在变成从状�?11022转换成状�?000000�Q�所需最��的步骤.

那么状态是怎样转换的呢�Q?br /> 很显然。，每次青蛙跳都会触发状态的转换�Q�我们在每个状态时搜烦每种可能的�{换，我们记初始状态�ؓS(S�{�于三进�?11022�Q�记要求解的��gؓOPT(S),假如可以转换到t1,t2,...tk.
那么�Q�显�?br />

OPT(S)=min(1+OPT(t1),1+OPT(t2),.,1+OPT(tk));

另外�Q�由于最�l�状态�ؓ0,所以OPT(0)=0,��是说已�l�在最�l�状态了�Q�就不需要一步就可以了�?br /> 有了上面�q�个�{�式�Q�我们可以递归求解了，但是如果单纯的递归�Q�会��D��大量的重复计��，所以这里我们用备忘录的�Ҏ��Q�记下已�l�求解出来的OPT(x),攑֜�一个数�l�里�Q�由于只�?块石��_��所以最多我们需�?^7=2187个状态。我们用一�?187个元素的数组, 其中�W�i个元素表�C�OPT(i)�Q�初始化每个元素�?1表示�q�未求解。OPT(0) 可直接初始化�?.

到此我们�q�有一个问题，怎么能够在算法结束的时候打印出最优的步骤呢？按照�q�个步骤�Q�我们可以重建出青蛙是如何在最优的情况下过河的。�ؓ此，我们可以再用一个步骤数�l�，每次在采取最优步骤的时候记录下来�?br />
整个��法如下�Q?br />

package test;

import java.util.Arrays;
/**
*
* @author Yovn
*
*/
public class FrogJump {

    private int steps[];
    private int states[];


    private static class Step
    {
        int offset=-1;
        int jump;
        int jumpTo;
    }


    private Step jumps[];
    private int initS;
    public FrogJump()
    {
        steps=new int[81*27];
        states=new int[7];
        for(int i=0;i<3;i++)states[i]=1;
        for(int i=4;i<7;i++)states[i]=2;
        Arrays.fill(steps, -1);
        steps[0]=0;
        jumps=new Step[81*27];
        initS=makeS();
    }

    public int shortestSteps(int s)
    {
        if(steps[s]==-1)
        {

            int minStep=Integer.MAX_VALUE;
            Step oneStep=new Step();
            for(int i=0;i<7;i++)
            {
                if(states[i]==1)
                {
                    if(i>4)
                    {
                        states[i]=0;
                        minStep = recurFind(minStep,oneStep,i,7-i);
                        states[i]=1;
                    }
                    else
                    {
                        if(states[i+1]==0)
                        {
                            states[i]=0;
                            states[i+1]=1;
                            minStep = recurFind(minStep,oneStep,i,1);
                            states[i]=1;
                            states[i+1]=0;

                        }
                        if(states[i+2]==0)
                        {
                            states[i]=0;
                            states[i+2]=1;
                            minStep = recurFind(minStep,oneStep,i,2);
                            states[i]=1;
                            states[i+2]=0;

                        }
                    }
                }
                else if(states[i]==2)
                {
                    if(i<2)
                    {
                        states[i]=0;

                        minStep = recurFind(minStep,oneStep,i,-1-i);
                        states[i]=2;
                    }
                    else
                    {
                        if(states[i-1]==0)
                        {
                            states[i]=0;
                            states[i-1]=2;
                            minStep = recurFind(minStep,oneStep,i,-1);
                            states[i]=2;
                            states[i-1]=0;

                        }
                        if(states[i-2]==0)
                        {
                            states[i]=0;
                            states[i-2]=2;
                            minStep = recurFind(minStep,oneStep,i,-2);
                            states[i]=2;
                            states[i-2]=0;

                        }
                    }
                }

            }
            steps[s]=minStep;
            jumps[s]=oneStep;


        }
        return steps[s];

    }

    private final int recurFind(int minStep, Step oneStep, int pos, int jump) {
        int toS=makeS();
        int r=shortestSteps(toS);
        if(r         {
            oneStep.jump=jump;
            oneStep.offset=pos;
            oneStep.jumpTo=toS;
            minStep=r+1;
        }
        return minStep;
    }



    public void printPath()
    {
        int s=initS;
        int i=1;

        while(s!=0)
        {


            System.out.println("["+(i++)+"] Frog at #"+jumps[s].offset+" jumps #"+jumps[s].jump);
            s=jumps[s].jumpTo;

        }
    }
    private final int makeS() {

        int r=0;
        int p=1;
        for(int i=0;i<7;i++)
        {
            r+=p*states[i];
            p*=3;
        }
        return r;
    }

    /**
    * @param args
    */
    public static void main(String[] args) {
        FrogJump fj=new FrogJump();
        int steps=fj.shortestSteps(fj.initS);

        System.out.println("use "+steps+" steps!");
        fj.printPath();

    }

}

�q�行�l�果�Q?br />

use 21 steps!
[1] Frog at #2 jumps #1
[2] Frog at #4 jumps #-2
[3] Frog at #5 jumps #-1
[4] Frog at #3 jumps #2
[5] Frog at #1 jumps #2
[6] Frog at #0 jumps #1
[7] Frog at #2 jumps #-2
[8] Frog at #0 jumps #-1
[9] Frog at #4 jumps #-2
[10] Frog at #2 jumps #-2
[11] Frog at #0 jumps #-1
[12] Frog at #5 jumps #2
[13] Frog at #3 jumps #2
[14] Frog at #1 jumps #2
[15] Frog at #5 jumps #2
[16] Frog at #3 jumps #2
[17] Frog at #5 jumps #2
[18] Frog at #6 jumps #-1
[19] Frog at #5 jumps #-2
[20] Frog at #3 jumps #-2
[21] Frog at #1 jumps #-2

DoubleH 2009-01-06 22:27 发表评论

【分享】今日某公司的电话面试题

DoubleH — Wed, 10 Dec 2008 13:44:00 GMT

写一个函敎ͼ�输出前N个数�Q�从7开始）�Q�这N个数满��如下3个条件中的�Q意一�?br /> 1.整出7
2.各位上的数字之和整除7�Q?比如34)
3.��L��位上包含数字7

附我的代码：

void printN(int n)
{


    int c=0;
    int i=7;
    do
    {
        if(i%7 ==0)
        {
            printf("%d\n",i);
            c++;
        }
        else
        {
            int j=i%10;
            int k=j;
            int s=k;
            int p=10;
            while(k             {

                if(j==7)
                {
                    printf("%d\n",i);
                    s=0;
                    c++;
                    break;

                }
                else
                {
                    j=((i-k)/p)%10;
                    s+=j;
                    k=j*p+k;
                    p*=10;

                }
            }
            if(s&&s%7==0)
            {

                printf("%d\n",i);
                c++;
            }


        }
        i++;
    } while (c<n);
}

DoubleH 2008-12-10 21:44 发表评论