独自登高楼 望断天涯路

废了不少脑细胞 public static int newsquareCount(int a , int b){ int k=a<b?a:b; return k*(k+1)*(2*k+1)/6+(Math.abs(a-b)*k*(k+1)/2); }

登陆的时候进行一次双向非对称协议1.客户端先发起非对称请求2.服务端返回一次非对称响应3.在返回数据中用请求密钥及响应密钥返回在业务数据的加密中就可以使用对称密钥加密4.在业务数据请求是用请求密钥对称加密5.在业务数据响应时用响应密钥对称加密 非对称加密可以使用RSA,对称加密可使用DES  本文章属于原创，转载请注明出处。http://blog.youkuaiyun.com/lastsweetop/

数据结构使用不相交森林，复杂度 O(ElgV)package com.eshore.sweetop.mintree;import java.util.ArrayList;import java.util.Collections;import java.util.List;import com.eshore.sweetop.exdataframe.DisjointSetForest;public c

package com.eshore.sweetop.mapbase;import java.awt.Color;import java.util.LinkedList;public class SCCTest {    private static int time;    public static void DFS(Graphics g,LinkedList list) {        f

package com.eshore.sweetop.os;public class Peterson {    boolean[] interested=new boolean[2];    int turn;        /**     * @param process     */    public void enter(int process){        int other;  

package com.eshore.sweetop.mapbase;import java.awt.Color;import java.util.LinkedList;import java.util.Queue;/** * Class GTest * @author wudongdong * GTest.java     * Dec 4, 2008 */public class GTest {

/** *  */package com.eshore.sweetop.mapbase;import java.awt.Color;import java.util.LinkedList;/** * Class TopoLogical * @author wudongdong * TopoLogical.java     * Dec 5, 2008 */public class TopoLogic

/** *  */package com.eshore.sweetop.mapbase;import java.awt.Color;/** * Class DFSTest * @author wudongdong * DFSTest.java     * Dec 5, 2008 */public class DFSTest {    private static int time;    publ

package com.eshore.sweetop.exdataframe;public class DisjointSetForest {        public void makeSet(DisjointSetNode node){        node.setParent(node);        node.setRank(0);    }        public void l

package com.eshore.sweetop.exdataframe;/* * mark */public class FibHeap {    private FibNode min;    private int count;    private FibNode root;    public FibHeap() {        root = new FibNode();     

package com.eshore.sweetop.exdataframe;public class BinomialHeap {    private BinomialNode head;    public BinomialNode getHead() {        return head;    }    private void setHead(BinomialNode head) 

package om.eshore.sweetop.minpath;public class BellmanFord extends Graphics {        public BellmanFord(Vertex...vs){        for (Vertex v : vs) {            list.add(v);        }    }        @Overrid

package com.eshore.sweetop.dataframe;import java.math.BigInteger;import com.eshore.sweetop.data.KeyData;public class DoubleOpenHash extends OpenHash {    public DoubleOpenHash(int size) {//      super

package com.eshore.sweetop.sort;import java.util.Arrays;public class Bubble {    public static void sort(int[] a,boolean reverse){        for (int i = 0; i 1; i++) {            for (int j = i+1; j

package com.eshore.sweetop.dataframe;import java.util.Random;import com.eshore.sweetop.data.KeyData;import com.eshore.sweetop.data.Node;/* * bintree */public class Bintree {    private Node root;

packagecom.eshore.sweetop.dataframe;importcom.eshore.sweetop.data.KeyData;/**开放寻址法解决碰撞问题*/publicclassOpenHash{protectedKeyData[]table;publicOpenHash(intsize){table=newKeyD

package com.eshore.sweetop.dataframe;import java.util.LinkedList;import com.eshore.sweetop.data.KeyData;public class MultiChainedHash {    LinkedList[] table = new LinkedList[(int)Math.pow(2, 6)];

package com.eshore.sweetop.exdataframe;public class DisjointSetLink {    private DisjointElement head;    private DisjointElement tail;        public void makeSet(DisjointElement element){        head

package om.eshore.sweetop.minpath;public class Dijkstra extends Graphics {    Dijkstra(Vertex...vs){        int index=0;        for (Vertex v : vs) {            list.add(v);            v.setIndex(inde

package om.eshore.sweetop.minpath;import java.awt.Color;import java.util.LinkedList;public class Dag extends Graphics {    private int time = 0;    public Dag(Vertex... vs) {        for (Vertex v : vs

package om.eshore.sweetop.minpath;import java.util.ArrayList;import java.util.List;public abstract class Graphics{    protected List list=new ArrayList();        public void initSingleSource(Vertex v)

package com.eshore.sweetop.sort;import java.util.Arrays;public class Heap {    private static int parent(int i) {        return (i-1) >> 1;    }    private static int left(int i) {        return i 1|1

package com.eshore.sweetop.exdataframe;public class BTree {    private BNode root;    private int min;    public BTree() {        BNode node = new BNode();        node.setLeaf(true);        node.setCo

package com.eshore.sweetop.cupidity;import java.util.ArrayList;import java.util.List;public class Quest {    Qt[] qt = { new Qt(4, 70), new Qt(2, 60), new Qt(4, 50), new Qt(3, 40),            new Qt(1

    //递归版本    public void recursive(){        activitySelector(s,f,-1,a.length-1);    }        public void activitySelector(int[] s, int[] f, int i, int n) {        int m = i + 1;        while (m 1?0:

package com.eshore.sweetop.dataframe;import java.util.LinkedList;import com.eshore.sweetop.data.KeyData;public class ChainedHash { LinkedList[] table = new LinkedList[10]; public void insert(KeyData o

package com.eshore.sweetop.dataframe;public class Quene {    private int head=-1;    private int tail=0;    private int[] q;        public Quene(){        q=new int[100];    }        public Quene(int 

package com.eshore.sweetop.sort;import java.util.Arrays;public class Count {    public static int[] sort(int a[]){        int[] b=new int[a.length];                //100是基数，可以处理100以下的排序，根据实际情况调整      

package com.eshore.sweetop.dataframe;import java.util.Arrays;public class MaxHeapQeuen {    private static int parent(int i) {        return (i - 1) >> 1;    }    private stati

最近用到很多算法的问题，才发现有些东西忘了就此机会好好打下基础。代码我会一一发出，和大家共同学习。

package com.eshore.sweetop.orderstatistic;import java.util.Random;public class RandomSelect {    private static Random rd = new Random(47);    public static int select(int[] a, int i) {        return 

package com.eshore.sweetop.sort;import java.util.Arrays;public class Radix {    public static int[] sort(int[] a,int d){        int[] b=new int[a.length];        for (int i = 0; i                     

package com.eshore.sweetop.sort;import java.util.Arrays;public class Quick {    private static int partition(int[] a, int p, int r) {        int x = a[r];        int i = p - 1;    

package com.eshore.sweetop.sort;import java.util.Arrays;public class Insertion {    public static void sort(int[] a,boolean reverse){        int key=0,i=0;        for(int j=1;j    

package com.eshore.sweetop.sort;import java.util.Arrays;import java.util.Random;public class RandomQuick {    private static Random rd = new Random(47);    private static int randomPartition(int[] a,i

package com.eshore.sweetop.dataframe;public class MyLinkedList {    private Element head;        public void insert(int x){        Element e=new Element(x);        e.next=head;        if(head!=null){ 

package com.eshore.sweetop.dataframe;import com.eshore.sweetop.data.KeyData;import com.eshore.sweetop.data.Node;import com.eshore.sweetop.data.RBNode;public class RBTree {    private RBNode root;    p

package com.eshore.sweetop.dataframe;import com.eshore.sweetop.data.KeyData;import com.eshore.sweetop.data.Node;import com.eshore.sweetop.data.RBNode;public class RBTree {    private RBNode root;    p

package com.eshore.sweetop.cupidity;import java.util.ArrayList;public class Huffman {    private char[] c = { a, b, c, d, e, f };    private int[] f={45,13,12,16,9,5};        class Node{  

package com.eshore.sweetop.dataframe;import java.math.BigInteger;import com.eshore.sweetop.data.KeyData;public class DoubleOpenHash extends OpenHash {    public DoubleOpenHash(int size) {//      super