财富猪Blog

大海商城

zhouhaizhe@gmail.com(admin) — Fri,06 Aug 2010 00:20:59 +0800

大海商城

拍照备案已成定局

zhouhaizhe@gmail.com(admin) — Sat,17 Jul 2010 21:07:10 +0800

“签订协议我们不担心，上传身份证我们不担心，写保证书我们也不担心，但我们就是担心需要现场拍照……” 据一名行业网站的站长透露，目前他最担心的就是需要现场拍照，因为网站目前都还未真正盈利，而拍照费用无疑是增加了一笔不小的建站费用，他目前有放弃做网站的念头。

就目前而言，拍照备案已成定局，那么上面有政策了，下面就要有对策，让我们来看看国内站长与IDC一般是如何应对的。

站长应对方法：

乖乖服从政策立即前去拍照

选择这个策略实属无奈，毕竟胳膊拧不过大腿，还是遵守国家政策，该拍照的拍照，该备案的备案，反正自己不犯法，有什么大不了的，无非就是多花点冤枉钱。有这个想法的站长不在少数，起码不算是个下策。

先不拍照看能不能作弊

显然很多站长及负责人都选择这样的策略，因为只要不是新开的网站，以前的旧站重新拍照备案也是九月份的事情，急不来，还是等等，也许还有那么点转机，就如同7月9日的专项备案取消一事，可将一部分站长开心了一回。

不拍照转移国外

从09年底网站严打以来，就陆续有国内站长开始将网站迁出国外，并戏称“自己出不了国，让网站出国逛逛也不错！”随着拍照备案开始提上正轨，相信不少站长会将此方法作为自己的第一策略。目前国内站长会首选美国主机，其次是韩国主机，最后是香港主机。因为美国主机价格合理，而且空间大小都是以G来计，所以最受站长热捧，特别是godaddy上的一款150G大小，年付价格还不到400元，成为站长的首选。其他美国主机商也各有特色，有以访问速度快著称、也有以空间容量大著称、还有以免费IP数量多著称，总之是花样特色都不少。同时部分美国主机商开始将设置中文客服纳入日程，相信这一服务措施会加快国内更多网站的外迁速度。

但是国外空间有个不好的地方，就是访问速度不稳定，有时候很快，有时候慢得让人想砸电脑，这也成为国外主机一直以来的诟病。

不拍照停止做站

这是最无奈的选择。“玩不起我躲得起”，放弃做站成为部分站长最终无奈的选择，对于他们而言，结束一段做站历程也许是另一段人生历程的开始，天无绝人之路，相信有更好的路在等待着自己。

下面是一个在DZ论坛的投票，大体可以看出站长的选择是怎样的。感谢网友xixigaga提供，投票地址：http://www.discuz.net/thread-1792244-1-1.html

IDC应对方法：

认真贯彻国家政策积极开展拍照备案工作

IDC的角色很复杂，他们如果认真贯彻拍照备案就可以不用遭到来自上面的压力，但却要承受站长不签约不续费转投别家的经济压力，两头都有压力，实属不易。

先不贯彻看能不能折中一下

毕竟真正的期限还未到，所以先放着，备案的事也只是提要签署一些协议和上传身份证、企业资格证等扫描件，不直接表明需要拍照备案，以免将站长吓跑了，即使站长问起来也会说拍照随时来都可以，不急。这样的回复是目前国内主机商说得最多的，他们希望站长先买空间，付了钱之后的事情都好说。

明修栈道暗渡陈仓

明着着手准备拍照备案工作，暗地里开始开展国外主机业务，而且打的旗号就是“国外主机免备案，方便快捷！”这其实也是算是个公开的秘密，诸多IDC已经开展了此项业务，特别是一些中小型IDC，如果国内主机卖得不好起码还有国外主机卖，留条后路总好过自掘坟墓。

大浪淘沙关门大吉

国内互联网从来不缺竞争对手，互联网上IDC公司倒闭是随时都在发生的事情。网跃科技、西湖数据、明网、网新数据/神胜网络、东莞云龙科技，这些曾经的知名IDC服务商开始离开人们的视野，离开了互联网。相信随后拍照政策的逐步落实，还会有一大批IDC死在了政策的管理之下而非经营的管理之下。

总结：

笔者认为，站长和IDC其实是拴在一根绳上的蚂蚱，是唇亡齿寒、城门失火殃及池鱼的的关系。近日也有IDC提出只需提供清晰免冠照片即可，无需上门拍照，细细分析这何尝不是二者之间的一种互助？（文/王伟明）

本文出处：http://www.graymud.com 欢迎转载，但请注明出处。

网络象棋之二（拖拽的实现）

zhouhaizhe@gmail.com(admin) — Fri,23 Apr 2010 14:54:15 +0800

这篇将介绍网页中元素如何实现拖拽效果。
让元素在页面中移动，其实并不复杂，总体思想是分为以下几点。
1.重载页面中的mouse事件。
2.告诉页面那些元素可以移动。
3.获取鼠标和元素在页面中的坐标值。
4.改变元素的坐标值使其移动。
以上篇制作象棋棋盘为基础，来介绍程序如何实现。
在的最下面添加一个div元素。
如：

添加这个元素的作用是为了使被拖拽元素在拖拽时显示在所有棋子之上所使用的临时元素。

首先我们要重载需要移动元素的onmousedown事件。当鼠标点击item时就把当前item赋给javascript中的全局变量dragObject，即告诉了页面需要移动的是哪个item。
并且取得了当前鼠标相对于item的坐标，以在移动元素时使用。
var dragObject = null;
var mouseOffset = null;
var helpContainer = null;
var parentTarget = null;

Number.prototype.NaN0=function(){return isNaN(this)?0:this;}

//重载需要移动的item的onmousedown事件
function makeDragDropable(item){
    if(!item) return;
    item.onmousedown = function(ev){
        dragObject = this;
        mouseOffset = getMouseOffset(this, ev);
        if(dragObject)
            helpContainer.appendChild(dragObject.cloneNode(true));    //克隆元素到helpContainer里
        parentTarget = dragObject.parentNode;
        return false;
    };
}
//取得鼠标相对于item的坐标
function getMouseOffset(target, ev){
    ev = ev || window.event;    //ev在Firefox中只能被当前函数获取，而在IE里是全局变局
    var docPos = getPosition(target);
    var mousePos = mouseCoords(ev);
    return {x:mousePos.x - docPos.x, y:mousePos.y - docPos.y};
}
//item相对于整个document的绝对坐标
function getPosition(e){
    var left = 0;
    var top = 0;
    while(e.offsetParent){
        left += e.offsetLeft + (e.currentStyle?(parseInt(e.currentStyle.borderLeftWidth)).NaN0():0);
        top += e.offsetTop  + (e.currentStyle?(parseInt(e.currentStyle.borderTopWidth)).NaN0():0);
        e = e.offsetParent;
    }
    left += e.offsetLeft + (e.currentStyle?(parseInt(e.currentStyle.borderLeftWidth)).NaN0():0);
    top += e.offsetTop  + (e.currentStyle?(parseInt(e.currentStyle.borderTopWidth)).NaN0():0);

    return {x:left, y:top};
}
//mouse相对于整个document的绝对坐标
function mouseCoords(ev){
    if(ev.pageX || ev.pageY){
        return {x:ev.pageX, y:ev.pageY};
    }
    return {x:ev.clientX + document.body.scrollLeft - document.body.clientLeft,
            y:ev.clientY + document.body.scrollTop - document.body.clientTop};
}
window.onload = function(){
    helpContainer = document.getElementById("helpContainer");
    boardPos = getPosition(document.getElementById("chessboard"));
    makeDragDropable(document.getElementById("zhu_0_0"));    //使“车”这个棋子拥有了拖拽的基础，其它棋子的拖拽添加方法一样。
}需要的信息都取得了，为了使item移动，必需重载页面的onmousemove事件。
document.onmousemove = mouseMove;
function mouseMove(ev){
    ev = ev || window.event;
    var target = ev.target || ev.srcElement;
    var mousePos = mouseCoords(ev);
    //隐藏当前元素，显示help临时元素
    helpContainer.style.display = "";
    dragObject.style.display  = "none";
    //移动help元素
    helpContainer.style.top  = mousePos.y - mouseOffset.y - boardPos.y;
    helpContainer.style.left = mousePos.x - mouseOffset.x - boardPos.x;
}到这里移动元素的功能就实现了，但在下象棋时棋子只能在格子的十字中心的位置上。
下面我就介绍如何给棋子添加定位功能。
重载onmouseup事件，即在鼠标提起时所触发的事件。
document.onmouseup = mouseUp;
function mouseUp(ev){
    ev = ev || window.event;
    var mousePos = mouseCoords(ev);
    var dLength = dropTargets.length;
    //判断当前棋子是否在可走集合内
    for(var i = 0; i < dLength; i++){
        curTarget = dropTargets[i];
        curTargetPos = getPosition(curTarget);
        curTargetWidth = parseInt(curTarget.offsetWidth);
        curTargetHeight = parseInt(curTarget.offsetHeight);

        if(mousePos.x > curTargetPos.x
            && mousePos.x < (curTargetPos.x + curTargetWidth)
            && mousePos.y > curTargetPos.y
            && mousePos.y < (curTargetPos.y + curTargetHeight)){
            resetChessmanPos();
            if(eatChessman(curTarget)){
                //目标元素添加被拖拽棋子
                curTarget.appendChild(dragObject);
            }
            curTarget = null;
        }else{
            resetChessmanPos();
        }
    }
    dragObject = null;
}
//是否可以吃棋子
function eatChessman(curTarget){
    var obj = curTarget.firstChild;
    if(!obj) return true;
    if(dragObject){
        var temp = obj.id.split("_");
        var temp2 = dragObject.id.split("_");
        if(temp[1] == temp2[1]){
            dragObject.style.top = 0;
            dragObject.style.left = 0;
            return false;
        }else{
            //eatContainer.appendChild(obj);
            return true;
        }
    }
    return false;
}
//重设棋子坐标
function resetChessmanPos(){
    dragObject.style.top = 0;
    dragObject.style.left = 0;
    dragObject.style.display = "";
    helpContainer.style.display = "none";
}
var dropTargets = [];
function addDragDropTarget(dropTarget){
    dropTargets.push(dropTarget);
}
window.onload = function(){
    //在已有的代码中添加如下代码
    for(var row = 0; row < 10; row++){
        for(var col = 0; col < 9; col++){
            //添加棋子可走范围集合
            addDragDropTarget(document.getElementById("grid_"+row+"_"+col));
        }
    }
}棋子拖拽的功能基本上完成了。
不过象棋是有规则的哦，下面把规则加进去。
function chessRule(curTarget){
    var pTemp = parentTarget.id.split("_");
    var dTemp = dragObject.id.split("_")[0];
    var uTemp = dragObject.id.split("_")[1];
    var cTemp = curTarget.id.split("_");
    var y1 = cTemp[1];
    var x1 = cTemp[2];
    var y2 = pTemp[1];
    var x2 = pTemp[2];

    switch(dTemp){
        case "zhu":
            if(x1 == x2 || y1 == y2){
                if(x1 == x2){
                    return !isBlock(x1, y1, y2, "y");
                }
                if(y1 == y2){
                    return !isBlock(y1, x1, x2, "x");
                }
            }else{
                return false;
            }
            break;
        case "ma":
            var n = new Array(1, 2, 2, 1, -1, -2, -2, -1);
            var m = new Array(-2, -1, 1, 2, 2, 1, -1, -2);
            for(var i = 0; i < 8; i++){
                if((n[i]+parseInt(y2)) == y1 && (m[i]+parseInt(x2)) == x1){
                    if(Math.abs(n[i]) > Math.abs(m[i])){
                        var obj = document.getElementById("grid_"+(parseInt(y2)+n[i]/2)+"_"+x2);
                        if(obj.firstChild)
                            return false;
                        else
                            return true;
                    }else{
                        var obj = document.getElementById("grid_"+y2+"_"+(parseInt(x2)+m[i]/2));
                        if(obj.firstChild)
                            return false;
                        else
                            return true;
                    }
                }
            }
            return false;
            break;
        case "xiang":
            if(uTemp == 0 && y1 > 4){
                return false;
            }else if(uTemp == 1 && y1 < 5){
                return false;
            }else{
                var n = new Array(2, 2, -2, -2);
                var m = new Array(-2, 2, 2, -2);
                return loopPos(x1, y1, x2, y2, n, m);
            }
            break;
        case "shi":
            var n = new Array(-1, 1, -1, 1);
            var m = new Array(-1, -1, 1, 1);
            if(x1 < 3 || x1 > 5){
                return false;
            }else if(uTemp == 0 && y1 > 2){
                return false;
            }else if(uTemp == 1 && y1 < 7){
                return false;
            }else{
                return loopPos(x1, y1, x2, y2, n, m);
            }
            break;
        case "jiang":
        case "shuai":
            var n = new Array(0, 1, 0, -1);
            var m = new Array(-1, 0, 1, 0);
            if(x1 < 3 || x1 > 5){
                return false;
            }else if(uTemp == 0 && y1 > 2){
                return false;
            }else if(uTemp == 1 && y1 < 7){
                return false;
            }else{
                return loopPos(x1, y1, x2, y2, n, m);
            }
            break;
        case "pao":
            if(x2 == x1 || y2 == y1){
                if(x2 == x1){
                    if(isBlock(x1, y1, y2, "y") && isEat(curTarget, uTemp)){
                        return true;
                    }else if(!isBlock(x1, y1, y2, "y") && isEat(curTarget, uTemp)){
                        return false;
                    }else if(isBlock(x1, y1, y2, "y") && !isEat(curTarget, uTemp)){
                        return false;
                    }
                    return true;
                }else if(y2 == y1){
                    if(isBlock(y1, x1, x2, "x") && isEat(curTarget, uTemp)){
                        return true;
                    }else if(!isBlock(y1, x1, x2, "x") && isEat(curTarget, uTemp)){
                        return false;
                    }else if(isBlock(y1, x1, x2, "x") && !isEat(curTarget, uTemp)){
                        return false;
                    }
                    return true;
                }
            }else{
                return false;
            }
            break;
        case "bing":
        case "zu":
            if(uTemp == 0){
                if(y2 > 4){
                    var n = new Array(1, 0, -1);
                    var m = new Array(0, 1, 0);
                    return loopPos(x1, y1, x2, y2, n, m);
                }else{
                    if(parseInt(x2) == x1 && (parseInt(y2)+1) == y1){
                        return true;
                    }else{
                        return false;
                    }
                }
            }else if(uTemp == 1){
                if(y2 < 5){
                    var n = new Array(-1, 0, 1);
                    var m = new Array(0, -1, 0);
                    return loopPos(x1, y1, x2, y2, n, m);
                }else{
                    if(parseInt(x2) == x1 && (parseInt(y2)-1) == y1){
                        return true;
                    }else{
                        return false;
                    }
                }
            }
            break;
    }
    return true;
}

function loopPos(x1, y1, x2, y2, n, m){
    var l = n.length;
    for(var i = 0; i < l; i++){
        if((parseInt(x2)+n[i]) == x1 && (parseInt(y2)+m[i]) == y1){
            return true;
        }
    }
    return false;
}

function isEat(curTarget, uTemp){
    if(curTarget.firstChild && curTarget.firstChild.id.split("_")[1] != uTemp){
        return true
    }else{
        return false;
    }
}

function isBlock(num1, num2, num3, flag){
    var t1 = Math.max(num2, num3);
    var t2 = Math.min(num2, num3);
    var temp = null;
    for(var i = t2+1; i < t1; i++){
        if(flag == "x"){
            temp = document.getElementById("grid_"+num1+"_"+i);
        }else{
            temp = document.getElementById("grid_"+i+"_"+num1);
        }
        if(temp.firstChild != null)
            return true;
    }
    return false;
}

对function mouseUp(ev)方法添加规则部分。
function mouseUp(ev){
    ev = ev || window.event;
    var mousePos = mouseCoords(ev);
    var dLength = dropTargets.length;
    //判断当前棋子是否在可走集合内
    for(var i = 0; i < dLength; i++){
        curTarget = dropTargets[i];
        curTargetPos = getPosition(curTarget);
        curTargetWidth = parseInt(curTarget.offsetWidth);
        curTargetHeight = parseInt(curTarget.offsetHeight);

        if(mousePos.x > curTargetPos.x
            && mousePos.x < (curTargetPos.x + curTargetWidth)
            && mousePos.y > curTargetPos.y
            && mousePos.y < (curTargetPos.y + curTargetHeight)){
            if(chessRule(curTarget)){
                resetChessmanPos();
                if(eatChessman(curTarget)){
                    //目标元素添加被拖拽棋子
                    curTarget.appendChild(dragObject);
                }
                curTarget = null;
            }else{
                resetChessmanPos();
            }
        }else{
            resetChessmanPos();
        }
    }
    dragObject = null;
}前台部分基本完成了。下一贴将介绍如何利用DWR与后台进行交互。

查看网站在多种操作系统、浏览器下的浏览界面

zhouhaizhe@gmail.com(admin) — Fri,12 Feb 2010 20:57:45 +0800

很多做英文站的站长有可能需要这个小工具，查看网站在多种操作系统、浏览器下的界面情况

地址：Browsershots ( http://browsershots.org )

如果你是做英文站的，我建议你在完工前用这个小工具测试下，看看网站是否还有那些不足！

该站的另外一个小工具也很实用，http://www.colorblender.com，网页颜色选择器。

VPN连接上以后,不能上网解决办法

zhouhaizhe@gmail.com(admin) — Sat,30 Jan 2010 20:21:01 +0800

条件:家用电脑,一块网卡,通过ADSL虚拟拨号上网,然后通过VPN连接到公司的局域网. 现在只要VPN连接上以后,就不能上网了,断开以后又可以了.

解决方法:选中虚拟拨号连接图标,右键属性窗口,然后选中TCP/IP协议,点属性按钮,在出现的属性窗口里选择"高级",在常规里将"在远程网络上使用默认网关"前的复选框去掉,保存设置.以后就不会出这个问题了.

iframe框架页面实现自适应高度解决方案

zhouhaizhe@gmail.com(admin) — Sat,09 Jan 2010 09:40:29 +0800

经常会有父页面需要通过iframe嵌入另一个子页面,又要适时根据子页面的高度调整父页面中iframe的高度，这就要求页面必须具有自适应功能。自适应思想比较简单：就是父页面中iframe高度必须要适时根据子页面高度进行调整。由于涉及到js操作，因此对于不同域名的自适应解决方案有所不同，主要是在解决跨域问题。

对于同父级域名下的自适应高度：www.chinaz.com/index.html 页面中嵌入www.chinaz.com/xxx.html页面

1.0 http://jipiao.taobao.com/index.htm中关键代码

http://www.chinaz.com/xxx.htm" mce_src="http://www.chinaz.com/xxx.htm" frameborder="0" scrolling="no" style="height:0;">

页面增加如下JS:

2.子页面http://www.chinaz.com/xxx.htm 中嵌入如下代码。即可

不同父级页面，例如www.chinaz.com, book.chinaz.com域名完全不一样，解决办法是使用一个代理页面www.chinaz.com/proxy.htm www.chinaz.com/index.htm页面嵌入 book.chinaz.com/xxxx.htm，而xxx.htm需要隐藏嵌入www.chinaz.com/proxy.htm做为代理，可以将高度写在后面www.chinaz.com/proxy.htm#500，表示500px高度。

1.www.chinaz.com/index.htm页面中关键代码：

http://www.chinaz.com/xxxx.htm" mce_src="http://www.chinaz.com/xxxx.htm" frameborder="0" scrolling="no" style="height:0;">

增加如下JS:

2. www.chinaz.com/xxxx.htm 中关键代码：

http://www.chinaz.com/proxy.htm#597" mce_src="http://www.chinaz.com/proxy.htm#597" id="taobaoIframe">

3.在代理页面book.chinaz.com/proxy.htm中所有的代码如下：

http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

S矩阵算法

zhouhaizhe@gmail.com(admin) — Tue,22 Dec 2009 23:31:00 +0800

题目要求:
打印出如下的矩阵
1 6 7
2 5 8
3 4 9
for(int i=1;i<=m;i++){
    for(int j=1;j<=n;j++){
        if(j%2==0){
           print(j*m-(i-1));
        }else{
           print((j-1)*n+i);
        }
    }
}

矩阵原地转置的算法

zhouhaizhe@gmail.com(admin) — Tue,22 Dec 2009 22:36:04 +0800

几天同事问我一个问题：矩阵的在位转置或者是原地转置(transpose inplace)，意思就是尽量不分配额外的内存空间，把一个矩阵转置。
矩阵的存储结构是用一块线性内存来存储数据，然后记录宽度、高度，大致如下

class Matrix { double* data; int width, height; };

【问题分析】
因为没有额外空间可用，所以改变数据只能通过“交换”，也就是把矩阵中的两个元素交换位置，这个操作可以不使用任何额外存储空间。那么通过交换操作，可以衍生出来的更复杂的操作就是循环移位，大致意思就是一组数据向左或者向右移动一个位置，比如原来是
{ x a1 a2 a3 ... an y }，那么左移位后就是 { a1 a2 ... an y x }，显然通过连续的数据交换是可以实现这个操作的。那么我们的算法中可以使用的数据移动操作就只有这两种：swap(i, j)完成数据交换，move_data(src, dst)完成{src, dst}之间的数据循环移位。（要说明的是，显然数据循环移位操作，不仅仅局限于连续的数据）

矩阵转置，实质上是对存储索引的重新排列(permutation)，和排序有点类似，但不一样的是，排序是值排序，算法决定一个数据元素的最终位置的时候只要知道这个数据的数值就可以了，但是转置是对索引位置的排序，我们不关心数据值的大小，只关心它在源序列中的位置，而如果不用额外存储空间，这个信息是很难保存的。

比如对于一个3*4的矩阵

1  2  3  4
5  6  7  8
9 10 11 12转置后为：

1 5  9
2 6 10
3 7 11
4 8 12观察在内存中的存储形式，源矩阵是
S = { 1 2 3 4 5 6 7 8 9 10 11 12 }

目标矩阵是
D = { 1 5 9 2 6 10 3 7 11 4 8 12 }

转置问题就是对于S，求出D即可。S是先验可知的，只是和矩阵的宽度高度有关，D是S的一个置换。

【正推】

比较容易想到的思路就是对S中的每个元素S[i]，求出它在D中的位置j1，我们把S[j1]先保存一下，然后再看S[j1]应该在D中的位置，比如是j2，那么再看S[j2]应该被放到的位置j3，这样继续下去，就得到了一个子序列 { i, j1, j2, ... i }，最后一个一定是i，也就是说这个子序列最后必然要回到i，很容易想到啊，最后总有一个数据要填充到第一个数据的位置上，因为就这么些个数据，不可能出来一个洞洞啊，呵呵。我们把这个子序列称为T(i)

那么对这样一个子序列完成一个move_data操作之后，这些位置上的数据就安放好了，然后我们再寻找下一个子序列，从i+1开始，循环下去，直到所有的数据都放好了，就收工了。

这个算法的一个问题就是当我完成一个子序列T(i)后，如果i+1包含在T(i)中，那么T(i+1)和T(i)是一样的，必须要跳过i+1，看i+2，如果i+2也在T(i)中，那就继续跳过，所以我需要一个标志数组来标志整个序列中那些位置的数据是已经放好的了，那些数据是还没有放好的，我只要对那些没有放好的数据做move_data。那么这个额外的标志数组的大小和矩阵是一样大的，呵呵额外存储空间啊，不行，所以这个方法失败。

不用标志数组也可以，我可以事先先把整个序列划分成若干个互不重叠的子序列，然后再进行操作，但是划分结果保存在那里呢？呵呵，所以，这个方法还是不行。

【反推】

换个思路，也许就好了。

如果我们从目标矩阵开始呢，我们考虑D中的一个位置i，这个i应该由S中的S[j]来填充，那么我们直接把S[i..j]之间做一个循环移位，这样i位置就被正确的设置了，同时[i+1,j]之间的数据仍然是按原来在S中的顺序。如果我们考虑把i从第一个位置开始依次循环递加，那么每次操作之后，我都可以保证[1, i]之间是放好的，[i, n]之间是没有放好的，呵呵看出来好处了么？我们不再需要任何额外的存储空间来保存哪些数据是已经放好的了。

虽然原理是很容易，但是写出程序还是要费一点心思，关键是在于对于[i, n]之间的这些待放置数据，它们之间的相对顺序虽然没有乱，但是位置都变动了，所以你要能够一直跟踪这些位置变动信息。这个比看上去的要复杂一点。

最后的程序如下

void TransposeInplace()
{
    int from, to, offset, step;
    int i, j;
    for (i = to = offset = 0, step = width; i < width; ++i, --step, offset += height-1) {
        for (j = 0, from = i + offset; j < height; ++j, ++to, from += step) {
            _move_data(from, to);
        }
    }
    swap(width, height);
}显然，如果以move_data为单元操作，这个算法的复杂度是O(n)的，考虑到move_data本身也是O(n)的，那么这个算法的复杂度是O(n^2)

【再快一点】

能不能更快一些呢？呵呵

算法上的加速不是很容易了，但是技巧上的加速还是可以的。

move_data是O(n)的，但是swap就是O(1)的了，上面的算法中对于每一个数据都要通过move_data来进行放置，所以我想到的一个加速就是尽可能的用swap来取代move_data

假设m = min(width, height)，矩阵左上角的，大小为m×m 的方阵显然是可以通过交换来完成转置的，如果我们先用swap对这个小的子方阵做好转置，再对剩下的数据放置，也许就可以快一些了。

比如，对前面用过的那个3*4的矩阵

1  2  3  4
5  6  7  8
9 10 11 12首先变化成

1 5  9  4
2 6 10  8
3 7 11 12也就是左边的3*3的小方阵转置一下，右边的部分不动，这样变换后，子序列{ 1, 5, 9, 2, 6, 10, 3, 7, 11 }有序，相对位置不需要变动了，剩下的工作只是把子序列 {4, 8, 12} 移到矩阵末尾去。呵呵，这个要快很多吧。

再仔细推敲这个算法，可以写出程序来，这个程序的编写仍然是以跟踪数据索引的位置变动为难点。比第一个要稍微困难一点，但是也不致于写不出来。

程序如下

void TransposeInplaceQuick()
{
    int m = width < height ? width : height;
    int i, j;
    for (i = 0; i < m; ++i) {
        for (j = i+1; j < m; ++j) {
            int i_old = _index(j, i);
            int i_new = _index(i, j);
            swap(data[i_old], data[i_new]);
        }
    }
    if (m == width) {
        for (i = m; i < height; ++i) {
            for (j = 0; j < width; ++j) {
                _move_data(_index(j, i), j * (width + i - m + 1) + i);
            }
        }
    }
    else {
        int last = _index(width-1, height-1);
        int n = 0;
        for (j = width - 1; j >= m; --j) {
            int step = n;
            for (i = height - 1; i >= 0; --i, --last) {
                _move_data(_index(j, i) - step, last);
                step -= (width - 1 - j);
            }
            n += height - 1;
        }
    }
    swap(width, height);
}这个算法的时间复杂度仍然是O(n^2)的，但是要比第一个快一些。平均看来时间应该是前一个算法的一半。

财富怎样流进少数人口袋

zhouhaizhe@gmail.com(admin) — Tue,03 Nov 2009 12:33:21 +0800

　　前几天碰见老同学，闲聊。他比我小一岁，已半亿身家，唯一喜欢的事情就是赚钱，偶尔娱乐一下，去瑞士旅游，买点手表什么的。我们的差距已经很远，唯一的交集是我们曾经在校园共度美好的青年岁月。　　

　　他很不喜欢谈生意的历程，多年的磨练，使他的口才更加如火纯青，闲谈风月，胡说八道，没一句正题，而聊天却是有趣。所以，朋友说我口才好，销售技术一流，实在是过誉了。我这位老友，才是口吐莲花，潇洒自如，杀人于无形的杀手级商人。　

　　也就是说，我这样的半吊子喜欢上来闲扯，而真正的高手从来是闷声发大财，不屑于传经颂道的。我记得索罗斯说过，金融界上的高手是不能出名的，能够出名而不被淘汰的顶尖高手也就是巴菲特和索罗斯而已。

　今年在风雨飘摇之机，赚钱超过20亿美金的某个高手，我甚至记不住他的姓名，因为外界很少知道他;只是因为他的利润引起了国会的怀疑，召集他和包括索罗斯在内的另外四个华尔街枭雄过来质询。我才得以知道华尔街有如此厉害的人物。

　　这些具备惊人才华的财富高手是怎样赚钱的呢?让我们展开财富之旅。

我精于观察，善于分析，敏于口，拙于行。尽管干的不行，说得还比较正确，希望各位能够看完了，敏于行，拙于口，把钱包装满，把头抬高，心中充满希望，前方洒满阳光。

　　华尔街的那位高人约翰·保尔森(John Paulson)在大多数贪婪的精英忙着从次级债上谋求高额利润时洞察了其中的风险，转而卖空，据说他控制的对冲基金在2007年前仅仅有10亿美金的规模，而他今年的林润就超过37亿美金。眼高于定的索罗斯也出面请他喝茶，请教韬略，尽管索罗斯今年的利润也超过10亿。

　　我早年入行创业，接触到无数的曾经成功和现在成功的人，他们成功的那一刻，都是在和大众背道而驰。

　财富第一定律：大多数人是错误的.

　　这篇题目实际上写错了，应该是：你们的钱爱我。财富迅速的从大多数人的口袋里流进了少数人的口袋里。

　　去年我在出租车上听司机亢奋的说你应该买什么股票;今年的这个时候我听出租车司机悲伤的说你怎么还在玩股票呢?

　　我的朋友拥有几套房子，当上半年其中一套房子出手时，接盘的老兄是一个崇明的出租车司机。这位老兄在房子2000元时，没有买，说再等等;在房子4000时，没有买，说再等等;到了房子涨到8000多了，他决定无论如何要买了。

　　吓得我朋友马上把其他两套房子挂到中介，当时因为开发商没有办完手续，耽误了一些时间，于是他的这些房子卖不掉了。

　　我没有轻视出租车司机的意思，但是我很知道普罗大众的财富智慧是极其低下的。

　　甚至与金融界的很多从业人士在财富智慧上面也近乎于弱智。昨天和我的客户聊天，她身价千万，手中十几个股票，自己不太懂，就询问金融界的朋友。金融界的朋友也时常给出错误的方向。

　　所以，狼行万里吃肉，狗行百里吃屎;无论这世道如何变迁，掌握财富奥秘的人都不会贫穷。

另一些要开厂的人，创业阶段尽量节约成本，自己研究机器，从市面上购买二手的机器，或者自己购买部件拼装改造。这些工厂的折旧极低，就又赢得了成本的一点优势。当年，老王也曾经改造机器，尝试达到别人工厂新机器的效果，做出的产品价格也极低。不过后来输在市场的不成熟---我开拓了一个新的细分市场，这也是后话。

　　每一个市场里都有一批这样的高手，于是其他的工厂就等于为他们免费打开市场，财富也就慢慢发生了转移。

　　每个人创业的时候，本金都来自储蓄、借贷、股东等等。如果是常规的思路，很难出头。90%的企业死在3年之内，剩下的10%会有9成死在另一个三年里。罗伯特清崎曾经说是5年和5年，但那是在美国这个成熟商业社会里。在中国如此激烈的竞争环境里，3年都已经是很长的一个数字了。

　　我当年注册公司，排在工业区的700多位，3年后，我已经排在第一为了。前面的700多位全死了。

　　可怕吧?

　　因此，首先你做生意要寻找市场缝隙，做产品定位。现在资本流淌，如水银泻地，每一个缝隙都被资本和数不清的高人占据。一个新手，如果没有强大的市场分析能力和投资技巧，就会死得很快。

　　当然，如果你拥有权力资源是另一回事，中国生意7成在官场上，3成在民间。

　　但是，如果没有足够的资金，不要新开一个细分市场，你很难撑得住。

　　我三次创业，做贸易成功，是站在巨人头上，一起开拓一个新的市场，赢了;第二次做工厂，自己试图打开一个新的细分市场，输了，彻底的输了;第三次创业，又做一个新的细分市场，服务业，没有资本投入。我已经降低了所有可以降低的成本，但是每年也要消耗30多万的资金，这些资金的来源，是我穷尽了所有的智慧和脸面来获得，多少年?3年了。我还活者，生意在逐渐向上走。

　　扯开一句：成功的机会是为厚脸皮的人准备的。

　　整整十年，我的头发从黑变白，还是个不成功的小业主，但是我还活着。

　　我有野心，所以我所希望的是在这一次前所未遇的经济危机里站起来，突破头顶厚厚的天花板。

　　因为这是我唯一的机会：我的年龄已大，暮气逐渐侵蚀勇气;身体不再像10年以前，精力不再旺盛;这一次，所有的强者都被打击变得赢弱，有的是实力变得赢弱，有的是精神变得赢弱;在风暴中，篱笆将会被打出缝隙，提供机会给我.....

　　....给我们每一个人。

　　寻找细分的市场是一个极其辛苦的过程，有时候你所以为的细分市场并不存在。因此在准备一个生意时，多问问自己：这生意为什么是不可以做的?

　　如果确定后，不要多怀疑。你一定会碰到数不清的困难，你一定也会时常怀疑自己，消极起来;你需要时常修正原来的计划而不是放弃。

　　当然，你想走一条寻常的生意路，但是你会碰到无数的对手，资金强大和经验丰富，你的胜率有几何?

　　我碰见过很多会控制成本的小生意人，他们最终变得壮大，或者维持每年几十万的利润。

　　做地板的，会把地板榫头减少1-2毫米，不影响使用但是增加了0.11%的单位利润;做饮食店的，会凌晨3点中骑车十几公里去蔬菜批发市场购买，以降低蔬菜的成本，因此我们的很多民工多了饮酒作乐的小饭店场所;做塑钢的，会在杂牌外面贴名牌纸头----这个不太好，哈哈---直至市面上大多数名牌产品全部变成假货;

　　这些好的坏的，你都要学习。如果你坚持原则，恭喜你成为老王一样的人，欢迎你在中国走上世界上最艰难的生意路，如果你三年不死，我交你这个朋友;十年不死，你将在全球生存没有任何阻碍。

　　说起一个人的创业，金钱是一个重要的因素，还有一个因素就是台湾人讲的人脉，大陆人讲的关系。

　　比较下来，人脉这个词语更贴切一些。

　　很多的人了解这些，但是并不知道如何去经营人脉。很多熟人的财富来源都可以归结为人脉的积累。包括我上面所说的半亿身家的同学，他当年创业一分钱没出，完全靠积累的人力资源赚的第一桶金。当年投资给他的金主，完全也是冲着他积累数年的人脉头给他上千万的资金。

　　经营人脉是一件非常有难度的事情，因为这和你的性格、为人、处世态度、心胸有很大的关系。一个人如果能够性格开朗、善于交际、待人诚恳、利益共享、不斤斤计较、不目光短浅，才能够交接到大量的人际关系。

　　如今，网络的发达疏远了现实人们的交际，但是中国毕竟是一个熟人社会，面对面地交往才能够建立交情。

　　不得不说的是，很多人出来混场面，不但是你自己再混，有时候也是你的家人和你一起混。如果，家里人能够体谅你在外面的交际，你更容易打开局面。

　　为什么这么说呢?朋友之间的交往是长期的，细水长流和水到渠成的。你不能说，今天我需要某某给我帮忙，你送上钱去，人家就帮你;或者说，打一个电话，别人就会分分钟跑过来帮你做事情。没有一个人会缺钱或缺朋友到这份上。

　　朋友之间的交情在于意气相投，或谈得来，或共同喜欢什么，或者说是酒肉朋友。但是，即使是酒肉朋友，也要三番五次的打交道，才吃得出那点交情。

　　女人最反感的是男人在外面交际，一顿饭吃下来几个小时，不知道在胡扯些什么，浪费时间，又不回来陪她。如果这个人每天在外面，不用说肯定是男的不对。但是，如果有节奏的在外面，那这个女孩子还有怨言，多方阻拦，基本上可以肯定大多数情况下这个男的无法打开局面，不是绝对的，但是基本上是这样。

　　所以女人如果要一个相妻教子的丈夫，就不要指望他在事业上有什么发展。

　　我曾经以为读书和知识能够起决定性的作用，创业十年后，我知道人脉起七成的作用，无论这些人脉来自于官场还是民间。

　　否则这个丈夫在是非成堆的生意场上，某一天丈夫遇见什么苦难，需要别人深受相助，谁会出头帮你这个陌生人?

　　另一方面说起来，人生的琐碎，就是人生的大部分，交情不是天天轰轰烈烈，只是些微不足道的事情交织在一起。经营事业和经营友情都是些很难的事情。

　　当然经营婚姻是更难的事情。

　　我经营事业到今天没有特别的成功，经营友情以丢失大多数朋友告终，经营婚姻也没有是家庭衣食无忧妻子开心幸福；时常需要检讨，如何在人生的轨道上走好剩下的路程。

　　财富第二定律：关系决定大部分的财富

　　我在此处略略扯一扯官场，这是我在和某些官场人士段时间内获得的印象，经验不多，仅供参考。

　　很多草根业和官场扯上了关系，说实话，我不知道在中国做生意怎么可能不和官场打交道？除了我这种完全做点小生意的小商人。官员是我们国家的精英，我一直认为是这样。才华横溢的人大多去走了仕途，第二流的人才才在商场上打拼，第三流的人作黑道，第四流的走职场，第五流的人种地，第六流的人才讨饭，第七流的人留在网络上做闲逛，第八流的人从事娱乐业，第九流的人称作教授专家。

　　我就属于第七流的人，在第二流挣扎着求生。

　　和官员打交道一定要低调、有涵养、有领悟别人话语后面的无数话语的能力。如果你能领会到话语后面的话语，恭喜你，官员不讨厌你；如果你能领会第三层话语，你可以去混官场生意了；你能领会到第四层，你就刀枪不入了，将来反腐也到不了的身上；你能领会第五层以上，咳，做什么生意阿，直接去报考公务员了。

　　比如说我---举例，我向来没这个福气---去给官装了房子，官很满意，也付了钱--记住，聪明的官一定是付钱的，如果对方不付钱，千万不要再和他来往了，有朝一日你也会和他一样跌进牢狱。但是，有一点，你一定要让官明白，你决不会在找他了，也不会说什么。暗示一下，说话委婉一点。这样你才有机会让他记住你：这人可以交往。

　　那你才有机会成为官的朋友，这样你才能做体制内的生意。

　　好了，到此为止！

　　言归正传。

　　做生意就是做人，在上海做生意，是先做生意；在北方做生意，是先做人。上海人已经学会了西方那套，生意就是生意，先作生意，看你在生意场上的行事规矩都在路上，路子清爽，做人四海，那你再交朋友。

　　在北方，是先做人，为人仗义，心胸广阔，手腕得当，因此有人叫你这个朋友，给你生意做。生意第一次做砸了不要紧，关键是人仗义，继续作，没问题了，大家发财。第二次又砸了，从此不谈生意，只需交情----当然，你该干嘛干嘛去，也不要在生意场上混了。

　　无论在那边做生意，专业是最重要的。

　　好友曾经讽刺我不够专业，实际上我只是懒散而已，当我专业起来，没有人及得上。

　　如果我做生意有我上网的一半劲头，我2009年就可以重归百万富翁的队伍。

　　因此，各位同学，抓紧时间看吧，一旦那浪子回头，就没得废话读了。

　生意人需要的几类重要的人脉

1,顾客。或者是能够给你带来生意的人；

　　2，金主。能够借给你钱的人。银行、典当行都算在内；

　　3，公检法的人。生意人最容易惹是非，你怎么知道你会不会惹上官非呢？

　　4，医生。医疗体系越来越乱，有个医生朋友能保证你的健康不被误导。

　　5，行业内的专家。找到那些真正的专家，设法交往。

　　6，诤友。无他，能够帮助你自醒的人。

　　7，富豪---投资成功者。不是为了他们的钱，而是为了他们的投资经验。

　　8，狐朋狗友。能够解决你精神的压力。

　　财富第三定律：灵活的处事方式

　　我移民国外是一定会参与政治的。我相信人性本恶，如果自己不争取自己的利益，没有人会自动送上面包。华人几百年来下南洋卖猪仔，在世界各地被人欺负和歧视，绝对不是当地人的错。而是华人自己的错，因为华人自己的脸上就写着：欺负我吧。

　　美国电影电视剧里的华人角色，各个猥琐懦弱，不是被人扁，就是被人奸。连演坏人都是没用的，至少俄罗斯的黑手党出现美国银幕上都是气宇轩昂令人恐惧的。

　　这是什么原因?在中华大地做奴才惯了，以为到国外低眉顺眼会有人喜欢。

　　所有的人性都表明恶才是本性，因此基督教文明社会里的宗教主张人需要赎罪，需要做好事，才不能下地狱。你看圣经里时常有这样的故事：神发怒了，淹了多少大地，烧死了多少人。中国人未免心中嘀咕，这些人供奉你，信仰你，为什么你不保佑他们升官发财，却总是惩罚他们?

　　其实当年写圣经的那个小子肯定和我一样是无神论者，但是却洞察人是真他妈的不是东西，需要吓唬，不吓唬，一定会自相残杀，毁灭万物的。

　　所以，我到了无论哪个国度，一定要设法影响政治，得到对自己和自己的族群最有利的政策和利益趋向。当然我也明白，生活需要妥协，在和其他的族群争斗的同时，也要学会妥协，互相找到最合理的解决办法。

　　这就是那个操蛋的民主!

　　民主不需要精英，不需要学识，只需要一群混蛋在一起，不用武力的互相争论，投票，争斗和妥协而已。

　　但是不要在这里玩这个游戏，要留在体制内，小心做生意。网上的愤青和网特都和你无关，你只需要做好生意，这个才与你相关。

　　你的生活是最重要的。

　　那么你只要留心体制内的生意就可以，无论是基础建设还是其他什么，做生意灵活机动，犹太人数千年来在生意上如此成功，是因为他们适应所有的社会。

　　同时保持流动，世界各地都是你的家园，如果你实在是故土难离，随身带一包土就可以了。

　　我第三次创业的时候，已经身无分文，倒背100万债务。

　　那么这种情况下，你如何起步呢？对于我自己来说，我介入了装潢生意。而装潢生意当时已经竞争白热化，我既不懂技术也不懂怎样拉客户，也没有团队，更糟的是一分钱没有。

　　我做了大量的市场调查，寻找市场缝隙，在当年的市场情况之下，二手房交易刚刚开始，并迅速的增长，而大多数装潢公司并不屑于做这样的工作。我在网络上免费发布了第一条广告，就是二手房维修和翻新的业务，以个人的名义。

　　在一个礼拜之后，我接到大概十个单子的寻单，但是由于我不懂行，不会报价，也不懂材料，我很快丢失了其中的九个单子，只有一个要维修卫生间的业务留给我面谈。

　　我的面谈很成功，然后我通过四年前认识的一个工匠----我当时留了他的联系方式。他并不是泥瓦匠，但是他找到了一个给我。我花了一周完成这个单子。

　　这个单子为我赢得200元利润，并支持我度过年关。

　　春节之后的一个年度，我赢得37个订单，其中二手房10套，8套都是小业务，2套是大装修。其间的利润帮助我做市场推广，我调整客户，因为二手房装修迅速的被竞争对手跟进，转向店铺装修和办公室装修。

　　这中间，我因为与老外打交道较多，顺利赢得老外的办公和酒吧装修若干。

　　在这中间，我不停的遭遇材料高价、假冒产品、工人欺诈、客户占便宜、拖款、自己等问题，而自己也经受了业务不熟的一切困难。

　　我现在在自己的行业，已经积累了足够的经验、核心技术、核心团队、行业影响，这使得我们处于不败的地位。

　　从创业走到今天，多少年？10年。

　　所以，你从几万元开始的时候，准备坚持多久？问一问自己。

　　在经济危机中，不会引起创业高峰，大多数人是恐惧的，他们的习惯是找到安全，而不是冒险。所以，找工作的人要超过创业的人。

　　但是，经济危机中，也的确不是创业的好时候，因为需求降低，机会减少。

　　所以，恐怕我还是劝你去打工

实现发送多个Ajax请求

zhouhaizhe@gmail.com(admin) — Tue,03 Nov 2009 12:29:03 +0800

目的是实现了，个人觉得在执行速度上不是很理想，希望大家帮忙改进,谢谢!

大家知道IE只能一次发送一个Ajax请求，你是否尝试过在一个页面上用Ajax请求多次,虽然可以实现我们发现代码很乱

我们来实现一个在页面呈现缓存的例子吧!

//获取Dom
function $(id) { return document.getElementById(id); }思路:我们把要加载的缓存放在一个集合中，再迭代集合实现所有的获取缓存请求

var cache={page:"Index",id:"Courses",element:$("Courses")};
//page为加载的缓存页面 id缓存ID,element显示缓存的Dom对象顺便插一句:这个例子用Jquery实现的了吗？可以尝试一下，呵呵,这几天好像跟Jquery有仇一样

上面定义了缓存对象，下面的代码就创建一个请求Ajax的方法,我们称之为: AsyncRequest

var xmlHttp = null;
function $AsyncRequest(request, callback) {
    this.method = request.method!=null&&request.method.toLowerCase()=="post"?"POST":"GET";
    this.url = request.url;
    this.params = request.params;
    this.dataType =request.dataType!=null&&request.dataType.toLowerCase() == "xml" ? "xml" : "text";
    this.async = request.async instanceof Boolean ? request.async : true;
    if (callback != null) {
        this.success = callback.success;
        this.error = callback.error;
        if (callback.start != null) callback.start();
    }
    if (xmlHttp == null) {
        if (window.XMLHttpRequest) xmlHttp = new XMLHttpRequest();
        else if(window.ActiveXObject)xmlHttp=new ActiveXObject("MSXML2.XMLHTTP")||new ActiveXObject("MICROSOFT.XMLHTTP");
        else{return false;}
    }

    var current = this;
   xmlHttp.open(this.method, this.url, this.async);
   xmlHttp.onreadystatechange = function() {
        if (xmlHttp.readyState == 4) {
            if (xmlHttp.status == 200) {
                if (current.success != null)
                    current.success(current.dataType == "xml" ? xmlHttp.responseXml : xmlHttp.responseText);
            }
            else {
                if (current.error != null)
                    current.error(xmlHttp.responseText);
            }
        }
    }
    if (this.method== "POST")
        xmlHttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
    xmlHttp.send(this.params);
}调用AsyncRequest方法实例:

  $AsyncRequest({ url:"http://127.0.0.1",method:"GET",async:true,dataType:"text" },

{ start: function () {//开始请求执行 },
   error:function(){//请求错误时执行},
   success: function (x) {//成功获取结果为x}
});
//简单的就可以像下面这样调用
  $AsyncRequest({ url: "/default.htm"}, {
            success: function (x) {alert(x);}
        });
好了，下面我们来请求获取缓存内容并显示出来了!新建一个方法叫loadCache()

function loadCache(cache,callback) {
    this.requestUrl = "/handler/cacheASHtml.ashx?cache.page=" + cache.page +
        "&cache.guid=" + cache.id + (cache.params != null ? "&" + cache.params : "")+"&"+Math.random();
        var nodeName=cache.element.nodeName;
        if (nodeName != null && (nodeName == "DIV" || nodeName == "SPAN")) {
            var element = cache.element;
        } else { alert('不支持的元素(div,span)' + nodeName); return false; }
        $AsyncRequest({ url: this.requestUrl }, { start: function () { element.innerHTML = "加载中!"; },
            success: function (x) {element.innerHTML = x;if (callback != undefined) callback(); }
        });
}我们加载显示一个缓存就可以这样调用

loadCache({ page: "Index", id: "NearIPrice", element: $("IPrice"));我们发现请求一个请求并不难，但是要请求多个时候就遇到问题了..

先将要请求的缓存放到一个集合中:

Code
            window.caches = [{ page: _p, id: "VipSchoolArchive", element: $("VipArchives") },
                { page: _a, id: "DefaultPageVipArchivesRightPart", element: $("VipArchiveAd") },
                { page: _a, id: "DefaultPageVipArchivesBottomPart", element: $("VipArchiveAdBottom")}];我们现在就要请求这所有的虎头缓存了!吃饭了直接上代码...呵呵

            window.caches = [{ page: _p, id: "VipSchoolArchive", element: $("VipArchives") },
                { page: _a, id: "DefaultPageVipArchivesRightPart", element: $("VipArchiveAd") },
                { page: _a, id: "DefaultPageVipArchivesBottomPart", element: $("VipArchiveAdBottom")}];

            loadCacheCollection(window.caches);

function loadCacheCollection(cacheArray) {
    cacheArray.reverse();
    var s = setInterval(function () {
        for (var i in cacheArray) {
            loadCache(cacheArray[i],
            function () {
                cacheArray.pop(cacheArray[i]);
                if (cacheArray.length == 0) clearInterval(s);
            });
        }
    }, 1000);
}完成了,如果有做的请留一个执行大概时间看看,顺便灌一个网址上去方便Seo:http://www.rsion.com