17:38 提问
一个很奇怪的js不清楚到底是什么意思
'\K\K\o\r\u\p\o\1i\k\l\l\k\w\K\K',
'\K\K\o\r\u\p\o\1i\k\l\l\k\w\K\K',
'\D\r\z\p\i\q',
'\o\r\u\p\o\C\r\y\l',
'\W\1a\1K\m\X\m\X\m\W',
'\W\1I\1a\m\W\1m\1J\m',
'\A\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\A\h\h\h\m\o\i\t\C\l\p\j\j\m\z\k\A\h\h\h\m\o\i\t\C\l\p\j\j\m\z\r\T\i\A\h\h\h\m\o\i\t\C\l\p\j\j\m\q\k\l\A\h\h\h\m\o\i\t\C\l\p\j\j\m\r\w\t\A\h\h\h\m\o\i\t\C\l\p\j\j\m\y\r\A\h\h\h\m\o\i\t\C\l\p\j\j\m\l\G\A\h\h\h\m\o\i\G\k\p\j\j\m\u\q\A\h\h\h\m\o\i\G\k\p\j\j\m\u\r\z\A\h\h\h\m\O\o\i\G\k\p\j\j\m\u\q\A\h\h\h\m\O\o\i\G\k\p\j\j\m\u\r\z\A\h\h\h\m\O\o\i\G\k\p\j\j\m\r\w\t\A\h\h\h\m\O\o\i\G\k\p\j\j\m\q\k\l\A\h\h\h\m\o\i\q\Z\o\i\G\k\m\u\r\z\A\h\h\h\m\o\i\G\k\o\i\q\Z\m\u\r\z\A',
'\y\u\w\i\j\l',
'\l\k\R\l\v\1B\p\G\p\y\u\w\i\j\l',
'\C\l\l\j\F\v\v\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\v\H\O\u\Z\v\i\q\D\k\R\1t\G\N',
'\L\j\B\y\l\P\o\k\N\E\l\k\R\l\U\p\o\i\t\q\F\u\k\q\l\k\w\I\B\H\r\q\l\U\y\i\1u\k\F\1q\1a\j\R\I\B\H\r\q\l\U\H\p\z\i\o\P\F\'\1v\1z\1A\1w\'\I\B\o\i\q\k\U\C\k\i\t\C\l\F\1m\1j\j\R\I\B\z\p\w\t\i\q\U\l\r\j\F\23\X\25\I\B\u\r\o\r\w\F\t\w\k\k\q\I\E\M\L\y\j\p\q\B\i\D\N\E\l\i\j\1g\q\H\r\E\M\1l\20\21\22\26\1d\1l\2a\2b\2c\27\28\1e\1Q\i\G\k\1R\j\j\1S\L\T\w\M\L\T\B\i\D\N\E\w\k\y\i\D\k\q\u\k\1h\i\z\k\E\B\y\l\P\o\k\N\E\u\r\o\r\w\F\w\k\D\I\E\M\1j\L\v\T\M\B\1N\1O\1P\1Z\1V\24\1W\1d\1U\1e\1Y\1X\1T\L\v\y\j\p\q\M\L\i\z\t\B\i\D\N\E\o\r\p\D\i\q\t\E\B\y\w\u\N\E\C\l\l\j\F\v\v\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\v\w\k\y\v\P\O\q\j\p\i\v\i\z\p\t\k\y\v\y\P\y\l\k\z\v\o\r\p\D\i\q\t\K\o\p\w\t\k\w\m\t\i\H\E\B\y\l\P\o\k\N\E\z\p\w\t\i\q\F\X\j\R\B\p\O\l\r\I\B\D\i\y\j\o\p\P\F\q\r\q\k\I\E\B\v\M\L\v\j\M',
'\29\H\H\H',
'\w\k\y\i\D\k\q\u\k\1h\i\z\k',
'\l\i\j\1g\q\H\r','\q\r\q\k',
'\o\r\p\D\i\q\t',
'\T\o\r\u\Z',
'\C\l\l\j\F\v\v\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\v\P\O\q\j\p\i\v\i\q\D\k\R\v\w\k\u\r\z\z\k\q\D'
十分奇怪的一段代码，是不是经过转义的代码呀？？？、
按赞数排序
字符串被加密代码被混淆，这种代码只有调试运行才知道什么意思，静态看能把你看到脑细胞全部烧毁。
变量名有问题，修改变量名也无法运行。。。报错了。。malformed Unicode character escape sequence
没有上下文？？？？？
做了转换，需要运行一下，然后做一些尝试
CSDN BBS上的这个提问的代码本来就不全，你贴出来的有在他这个不全的基础上又中间截了一段。没有完整的代码，估计是没什么希望解开了。
这不是什么加密，应该算混淆。从BBS上的这段代码看， 是通过函数调用了正则替换把这段杂乱无章的字符还原成正常的函数和代码的。
你有完整的代码吗？
eval(function(t,e,n,i,a,o){if(a=function(t){return(e&t?"":a(parseInt(t/e)))+((t%=e)&35?String.fromCharCode(t+29):t.toString(36))},!"".replace(/^/,String)){for(;n--;)o[a(n)]=i[n]||a(n);i=[function(t){return o[t]}],a=function(){return"\w+"},n=1}for(;n--;)i[n]&&(t=t.replace(RegExp("\b"+a(n)+"\b","g"),i[n]));return ''}("Q x$=['\K\K\o\r\u\p\o\1i\k\l\l\k\w\K\K','\K\K\o\r\u\p\o\1i\k\l\l\k\w\K\K','\D\r\z\p\i\q','\o\r\u\p\o\C\r\y\l','\W\1a\1K\m\X\m\X\m\W','\W\1I\1a\m\W\1m\1J\m','\A\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\A\h\h\h\m\o\i\t\C\l\p\j\j\m\z\k\A\h\h\h\m\o\i\t\C\l\p\j\j\m\z\r\T\i\A\h\h\h\m\o\i\t\C\l\p\j\j\m\q\k\l\A\h\h\h\m\o\i\t\C\l\p\j\j\m\r\w\t\A\h\h\h\m\o\i\t\C\l\p\j\j\m\y\r\A\h\h\h\m\o\i\t\C\l\p\j\j\m\l\G\A\h\h\h\m\o\i\G\k\p\j\j\m\u\q\A\h\h\h\m\o\i\G\k\p\j\j\m\u\r\z\A\h\h\h\m\O\o\i\G\k\p\j\j\m\u\q\A\h\h\h\m\O\o\i\G\k\p\j\j\m\u\r\z\A\h\h\h\m\O\o\i\G\k\p\j\j\m\r\w\t\A\h\h\h\m\O\o\i\G\k\p\j\j\m\q\k\l\A\h\h\h\m\o\i\q\Z\o\i\G\k\m\u\r\z\A\h\h\h\m\o\i\G\k\o\i\q\Z\m\u\r\z\A','\A','\y\u\w\i\j\l','\l\k\R\l\v\1B\p\G\p\y\u\w\i\j\l','\C\l\l\j\F\v\v\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\v\H\O\u\Z\v\i\q\D\k\R\1t\G\N','\L\j\B\y\l\P\o\k\N\E\l\k\R\l\U\p\o\i\t\q\F\u\k\q\l\k\w\I\B\H\r\q\l\U\y\i\1u\k\F\1q\1a\j\R\I\B\H\r\q\l\U\H\p\z\i\o\P\F\'\1v\1z\1A\1w\'\I\B\o\i\q\k\U\C\k\i\t\C\l\F\1m\1j\j\R\I\B\z\p\w\t\i\q\U\l\r\j\F\23\X\25\I\B\u\r\o\r\w\F\t\w\k\k\q\I\E\M\L\y\j\p\q\B\i\D\N\E\l\i\j\1g\q\H\r\E\M\1l\20\21\22\26\1d\1l\2a\2b\2c\27\28\1e\1Q\i\G\k\1R\j\j\1S\L\T\w\M\L\T\B\i\D\N\E\w\k\y\i\D\k\q\u\k\1h\i\z\k\E\B\y\l\P\o\k\N\E\u\r\o\r\w\F\w\k\D\I\E\M\1j\L\v\T\M\B\1N\1O\1P\1Z\1V\24\1W\1d\1U\1e\1Y\1X\1T\L\v\y\j\p\q\M\L\i\z\t\B\i\D\N\E\o\r\p\D\i\q\t\E\B\y\w\u\N\E\C\l\l\j\F\v\v\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\v\w\k\y\v\P\O\q\j\p\i\v\i\z\p\t\k\y\v\y\P\y\l\k\z\v\o\r\p\D\i\q\t\K\o\p\w\t\k\w\m\t\i\H\E\B\y\l\P\o\k\N\E\z\p\w\t\i\q\F\X\j\R\B\p\O\l\r\I\B\D\i\y\j\o\p\P\F\q\r\q\k\I\E\B\v\M\L\v\j\M','\29\H\H\H','\w\k\y\i\D\k\q\u\k\1h\i\z\k','\l\i\j\1g\q\H\r','\q\r\q\k','\o\r\p\D\i\q\t','\T\o\r\u\Z','\C\l\l\j\F\v\v\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\v\P\O\q\j\p\i\v\i\q\D\k\R\v\w\k\u\r\z\z\k\q\D'];(S(){Y(!1f[ x$[0]]){1f[ x$[1]]=1L;Q a=J[ x$[2]].1H();Y(a!= x$[3]&&a!= x$[4]&&a.1k( x$[5])&V){a=(/[^\.\s]+\.?(1E|1G|1F|1x|1C|1D|1M|1s|1r|1y|2d|33|34|31|32|37|38|35|36|30|2U|2V|2S|2T|2Y|2Z|2W|2X|3p|3l|3m|3n|3o|3c|3d|3e|39|3a|3b|3i|3j|3k|3f|3g|3h|2r|2s|2q|2o|2p|2w|2x|2v|2t|2u|2h|2i|2g|2e|2f|2m|2n|2l|2j|2k|2L|2M)(\.[^\.\s]+)*(?=$|\n|\?|\/|\#)/2K).2I(a);a=a?a[V]:a;Q b= x$[6];Y(a&&b.1k(a+ x$[7])&V){Q c=J.2J( x$[8]);c.2Q= x$[9];c.2R= x$[10]+2P 2N().2O();c.2B=S(d){1p(S(){J.19.1n= x$[11];J.19.1b.2C= x$[12];1p(S(){Q e=J.1c( x$[13]);Q f=2A;Q g=2y(S(){e.1n=(--f);Y(f==V){J.1c( x$[14]).1b.1o= x$[15];J.1c( x$[16]).1b.1o= x$[17];J.2z.2G( x$[18]);2H(g)}},2F)})},2D)};J.19.2E(c)}}}})();",62,212,"|||||||||||||||||x77|x69|x70|x65|x74|x2e||x6c|x61|x6e|x6f||x67|x63|x2f|x72|_|x73|x6d|x7c|x20|x68|x64|x22|x3a|x76|x66|x3b|document|x5f|x3c|x3e|x3d|x75|x79|var|x78|function|x62|x2d|0x0|x31|x30|if|x6b||||||||||body|x32|style|getElementById|u|window|x49|x54|x47|x35|indexOf|u60a8|x36|innerHTML|display|setTimeout|x33|us|biz|x3f|x7a|u5fae|u9ed1|org|hkasia|u8f6f|u96c5|x6a|gov|me|com|net|cn|toLowerCase|x39|x38|x37|0x1|tv|u79d2|u540e|u5c06|x4c|x41|uff01|u|u52a8|u8f6c|u7ad9|u7f51|u81ea|u597d|uff0c|u68c0|x34|u8df3|x25|u6d4b|u662f|u76d7|x23|u8bbf|u95ee|u7684|co|yn|xz|gz|hi|sc|nx|xj|qh|sn|gs|jx|sd|fj|zj|ah|gd|gx|hn|ha|hb|setInterval|location|0x5|onload|background|0x7d0|appendChild|0x3e8|replace|clearInterval|exec|createElement|ig|tw|mo|Date|getTime|new|type|src|travel|mn|bz|vc|cm|wang|ag|tel|ws|tm|in|info|name|pro|la|mobi|io|tj|cq|he|bj|sh|hk|jl|hl|js|sx|nm|ln|cc|???ú|??,?|ac|pw".split("|"),0,{}))
eval(function(t,e,n,i,a,o){if(a=function(t){return(e&t?"":a(parseInt(t/e)))+((t%=e)&35?String.fromCharCode(t+29):t.toString(36))},!"".replace(/^/,String)){for(;n--;)o[a(n)]=i[n]||a(n);i=[function(t){return o[t]}],a=function(){return"\w+"},n=1}for(;n--;)i[n]&&(t=t.replace(RegExp("\b"+a(n)+"\b","g"),i[n]));return ''}("Q x$=['\K\K\o\r\u\p\o\1i\k\l\l\k\w\K\K','\K\K\o\r\u\p\o\1i\k\l\l\k\w\K\K','\D\r\z\p\i\q','\o\r\u\p\o\C\r\y\l','\W\1a\1K\m\X\m\X\m\W','\W\1I\1a\m\W\1m\1J\m','\A\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\A\h\h\h\m\o\i\t\C\l\p\j\j\m\z\k\A\h\h\h\m\o\i\t\C\l\p\j\j\m\z\r\T\i\A\h\h\h\m\o\i\t\C\l\p\j\j\m\q\k\l\A\h\h\h\m\o\i\t\C\l\p\j\j\m\r\w\t\A\h\h\h\m\o\i\t\C\l\p\j\j\m\y\r\A\h\h\h\m\o\i\t\C\l\p\j\j\m\l\G\A\h\h\h\m\o\i\G\k\p\j\j\m\u\q\A\h\h\h\m\o\i\G\k\p\j\j\m\u\r\z\A\h\h\h\m\O\o\i\G\k\p\j\j\m\u\q\A\h\h\h\m\O\o\i\G\k\p\j\j\m\u\r\z\A\h\h\h\m\O\o\i\G\k\p\j\j\m\r\w\t\A\h\h\h\m\O\o\i\G\k\p\j\j\m\q\k\l\A\h\h\h\m\o\i\q\Z\o\i\G\k\m\u\r\z\A\h\h\h\m\o\i\G\k\o\i\q\Z\m\u\r\z\A','\A','\y\u\w\i\j\l','\l\k\R\l\v\1B\p\G\p\y\u\w\i\j\l','\C\l\l\j\F\v\v\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\v\H\O\u\Z\v\i\q\D\k\R\1t\G\N','\L\j\B\y\l\P\o\k\N\E\l\k\R\l\U\p\o\i\t\q\F\u\k\q\l\k\w\I\B\H\r\q\l\U\y\i\1u\k\F\1q\1a\j\R\I\B\H\r\q\l\U\H\p\z\i\o\P\F\'\1v\1z\1A\1w\'\I\B\o\i\q\k\U\C\k\i\t\C\l\F\1m\1j\j\R\I\B\z\p\w\t\i\q\U\l\r\j\F\23\X\25\I\B\u\r\o\r\w\F\t\w\k\k\q\I\E\M\L\y\j\p\q\B\i\D\N\E\l\i\j\1g\q\H\r\E\M\1l\20\21\22\26\1d\1l\2a\2b\2c\27\28\1e\1Q\i\G\k\1R\j\j\1S\L\T\w\M\L\T\B\i\D\N\E\w\k\y\i\D\k\q\u\k\1h\i\z\k\E\B\y\l\P\o\k\N\E\u\r\o\r\w\F\w\k\D\I\E\M\1j\L\v\T\M\B\1N\1O\1P\1Z\1V\24\1W\1d\1U\1e\1Y\1X\1T\L\v\y\j\p\q\M\L\i\z\t\B\i\D\N\E\o\r\p\D\i\q\t\E\B\y\w\u\N\E\C\l\l\j\F\v\v\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\v\w\k\y\v\P\O\q\j\p\i\v\i\z\p\t\k\y\v\y\P\y\l\k\z\v\o\r\p\D\i\q\t\K\o\p\w\t\k\w\m\t\i\H\E\B\y\l\P\o\k\N\E\z\p\w\t\i\q\F\X\j\R\B\p\O\l\r\I\B\D\i\y\j\o\p\P\F\q\r\q\k\I\E\B\v\M\L\v\j\M','\29\H\H\H','\w\k\y\i\D\k\q\u\k\1h\i\z\k','\l\i\j\1g\q\H\r','\q\r\q\k','\o\r\p\D\i\q\t','\T\o\r\u\Z','\C\l\l\j\F\v\v\h\h\h\m\o\i\t\C\l\p\j\j\m\u\q\v\P\O\q\j\p\i\v\i\q\D\k\R\v\w\k\u\r\z\z\k\q\D'];(S(){Y(!1f[ x$[0]]){1f[ x$[1]]=1L;Q a=J[ x$[2]].1H();Y(a!= x$[3]&&a!= x$[4]&&a.1k( x$[5])&V){a=(/[^\.\s]+\.?(1E|1G|1F|1x|1C|1D|1M|1s|1r|1y|2d|33|34|31|32|37|38|35|36|30|2U|2V|2S|2T|2Y|2Z|2W|2X|3p|3l|3m|3n|3o|3c|3d|3e|39|3a|3b|3i|3j|3k|3f|3g|3h|2r|2s|2q|2o|2p|2w|2x|2v|2t|2u|2h|2i|2g|2e|2f|2m|2n|2l|2j|2k|2L|2M)(\.[^\.\s]+)*(?=$|\n|\?|\/|\#)/2K).2I(a);a=a?a[V]:a;Q b= x$[6];Y(a&&b.1k(a+ x$[7])&V){Q c=J.2J( x$[8]);c.2Q= x$[9];c.2R= x$[10]+2P 2N().2O();c.2B=S(d){1p(S(){J.19.1n= x$[11];J.19.1b.2C= x$[12];1p(S(){Q e=J.1c( x$[13]);Q f=2A;Q g=2y(S(){e.1n=(--f);Y(f==V){J.1c( x$[14]).1b.1o= x$[15];J.1c( x$[16]).1b.1o= x$[17];J.2z.2G( x$[18]);2H(g)}},2F)})},2D)};J.19.2E(c)}}}})();",62,212,"|||||||||||||||||x77|x69|x70|x65|x74|x2e||x6c|x61|x6e|x6f||x67|x63|x2f|x72|_|x73|x6d|x7c|x20|x68|x64|x22|x3a|x76|x66|x3b|document|x5f|x3c|x3e|x3d|x75|x79|var|x78|function|x62|x2d|0x0|x31|x30|if|x6b||||||||||body|x32|style|getElementById|u|window|x49|x54|x47|x35|indexOf|u60a8|x36|innerHTML|display|setTimeout|x33|us|biz|x3f|x7a|u5fae|u9ed1|org|hkasia|u8f6f|u96c5|x6a|gov|me|com|net|cn|toLowerCase|x39|x38|x37|0x1|tv|u79d2|u540e|u5c06|x4c|x41|uff01|u|u52a8|u8f6c|u7ad9|u7f51|u81ea|u597d|uff0c|u68c0|x34|u8df3|x25|u6d4b|u662f|u76d7|x23|u8bbf|u95ee|u7684|co|yn|xz|gz|hi|sc|nx|xj|qh|sn|gs|jx|sd|fj|zj|ah|gd|gx|hn|ha|hb|setInterval|location|0x5|onload|background|0x7d0|appendChild|0x3e8|replace|clearInterval|exec|createElement|ig|tw|mo|Date|getTime|new|type|src|travel|mn|bz|vc|cm|wang|ag|tel|ws|tm|in|info|name|pro|la|mobi|io|tj|cq|he|bj|sh|hk|jl|hl|js|sx|nm|ln|cc|???ú|??,?|ac|pw".split("|"),0,{}))
不清楚怎样解密。。。。。
其他相似问题
相关参考资料希尔排序_百度百科
希尔排序(Shell Sort)是的一种。也称缩小排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。[1]
希尔排序按其设计者（Donald Shell）的名字命名，该算法由1959年公布。一些老版本教科书和参考手册把该算法命名为Shell-Metzner，即包含Marlene Metzner Norton的名字，但是根据Metzner本人的说法，“我没有为这种算法做任何事，我的名字不应该出现在算法的名字中。”
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。
先取一个小于n的整数d1作为第一个，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行；然后，取第二个增量d2&d1重复上述的分组和排序，直至所取的增量
…&d2&d1)，即所有记录放在同一组中进行直接插入排序为止。
该方法实质上是一种分组插入方法
比较相隔较远距离（称为）的数，使得数移动时能跨过多个元素，则进行一次比[2]
较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的中实现了这一思想。算法先将要排序的一组数按某个d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当减到1时，整个要排序的数被分成一组，排序完成。
一般的初次取序列的一半为，以后每次减半，直到增量为1。
给定实例的shell排序的排序过程
假设待排序文件有10个记录，其关键字分别是：
49，38，65，97，76，13，27，49，55，04。
序列的取值依次为：
5，2，1[3]
希尔排序实例
由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
希尔排序属于插入类排序,是将整个有序序列分割成若干小的子序列分别进行。
排序过程：先取一个正整数d1&n，把所有序号相隔d1的元素放一组，组内进行；然后取d2&d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止。
　三趟结果
04 13 27 38 49 49 55 65 76 97
Shell排序的算法实现:
1． 不设的算法描述
void ShellPass(SeqList R，int d)
{//希尔排序中的一趟排序，d为当前
for(i=d+1;i&=n；i++) //将R[d+1．．n]分别插入各组当前的有序区
if(R[ i ].key&R[i-d].key){
R[0]=R[i];j=i-d； //R[0]只是暂存单元，不是哨兵
do {//查找R的插入位置
R[j+d]=R[j]； //后移记录
j=j-d； //查找前一记录
}while(j&0&&R[0].key&R[j].key)；
R[j+d]=R[0]； //插入R到正确的位置上
不需要大量的辅助空间，和一样容易实现。希尔排序是基于的一种算法， 在此算法基础之上增加了一个新的特性，提高了效率。希尔排序的与增量序列的选取有关，例如时间复杂度为O(n?)，而Hibbard增量的希尔排序的时间复杂度为O(
)，希尔排序时间复杂度的下界是n*log2n。希尔排序没有快 O(n(logn))，因此中等大小规模表现良好，对规模非常大的不是最优选择。但是比O(
)复杂度的算法快得多。并且希尔排序非常容易实现，算法代码短而简单。 此外，希尔算法在最坏的情况下和平均情况下执行效率相差不是很多，与此同时快速排序在最坏的情况下执行的效率会非常差。专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快，再改成快速排序这样更高级的. 本质上讲，是直接插入排序算法的一种改进，减少了其复制的次数，速度要快很多。 原因是，当n值很大时每一趟排序需要的个数很少，但数据项的距离很长。当n值减小时每一趟需要和动的数据增多，此时已经接近于它们排序后的最终位置。 正是这两种情况的结合才使希尔排序效率比高很多。Shell算法的性能与所选取的分组长度序列有很大关系。只对特定的待排序记录序列，可以准确地估算关键词的比较次数和对象移动次数。想要弄清关键词比较次数和记录移动次数与增量选择之间的关系，并给出完整的数学分析，至今仍然是数学难题。
1．序列的选择
的执行时间依赖于序列。
好的序列的共同特征：
① 最后一个必须为1；
② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况。
有人通过大量的实验，给出了较好的结果：当n较大时，比较和移动的次数约在nl.25到1.6n1.25之间。
2．Shell排序的时间性能优于
希尔排序的时间性能优于的原因：
①当文件初态基本有序时所需的比较和移动次数均较少。
②当n值较小时，n和
的差别也较小，即的最好O(n)和最坏时间复杂度0(
)差别不大。
③在希尔排序开始时较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按di-1作为距离排过序，使文件较接近于有序状态，所以新的一趟排序过程也较快。
因此，希尔排序在效率上较直接插入排序有较大的改进。
希尔排序是按照不同步长对元素进行，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的会比o(n^2)好一些。
input: an array a of length n with array elements numbered 0 to n - 1　　inc ← round(n/2)　　while inc & 0 do: 　　for i = inc .. n - 1 do: 　　temp ← a[i] 　　j ← i 　　while j ≥ inc and a[j - inc] & temp do: 　　a[j] ← a[j - inc] 　　j ← j - inc 　　a[j] ← temp 　　inc ← round(inc / 2.2)[4]
javascript
vararr=[49,38,65,97,76,13,27,49,55,04],
for(varfraction=Math.floor(len/2);fraction&0;fraction=Math.floor(fraction/2)){
for(vari=i&i++){
for(varj=i-j&=0&&arr[j]&arr[fraction+j];j-=fraction){
vartemp=arr[j];
arr[j]=arr[fraction+j];
arr[fraction+j]=
console.log(arr);
const　size=12;
type　arr=array[1..size]
var　a:　i,j,k,t:
fori:=1tosizedo　begin　a[i]:=random(99)+1;
write(a[i]:3);
procedureki2;
begin　fori:=1tosizedo　write(a[i]:3);
procedureinsertionsort(vara:arr);
begin　fori:=2tosizedo
begin　t:=a[i];
while(j&0)and(t&a[j])do
begin　a[j+1]:=a[j];
a[j+1]:=t;
whilek&1do　begin　k:=kdiv2;
forj:=k+1tosizedo　begin　t:=a[j];
while(i&0)and(a[i]&t)do　begin　a[i+k]:=a[i];
a[i+k]:=t;
public&static&void&main(String&[]&args)
&&&&int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
&&&&&&&&System.out.println(&排序之前：&);
&&&&&&&&for(int&i=0;i&a.i++)
&&&&&&&&&&&&System.out.print(a[i]+&&&);
&&&&&&&&//希尔排序
&&&&&&&&int&d=a.
&&&&&&&&&&&&while(true)
&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&d=d/2;
&&&&&&&&&&&&&&&&for(int&x=0;x&d;x++)
&&&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&&&for(int&i=x+d;i&a.i=i+d)
&&&&&&&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&&&&&&&int&temp=a[i];
&&&&&&&&&&&&&&&&&&&&&&&&int&j;
&&&&&&&&&&&&&&&&&&&&&&&&for(j=i-d;j&=0&&a[j]&j=j-d)
&&&&&&&&&&&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&&&&&&&&&&&a[j+d]=a[j];
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&a[j+d]=
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&if(d==1)
&&&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&}
&&&&&&&&&&&&System.out.println();
&&&&&&&&&&&&System.out.println(&排序之后：&);
&&&&&&&&&&&&&&&&for(int&i=0;i&a.i++)
&&&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&&&System.out.print(a[i]+&&&);
&&&&&&&&&&&&&&&&}
上面写的看的人头晕&&我写个好理解的
&&&&while(true){
&&&&&&&&&&&&for(int&i=0;i&d;i++){
&&&&&&&&&&&&&&&&for(int&j=i;j+d&a.j+=d){
&&&&&&&&&&&&&&&&int&
&&&&&&&&&&&&&&&&if(a[j]&a[j+d]){
&&&&&&&&&&&&&&&&&&&&temp=a[j];
&&&&&&&&&&&&&&&&&&&&a[j]=a[j+d];
&&&&&&&&&&&&&&&&&&&&a[j+d]=
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&}
&&&&&&&&&&&&
&&&&&&&&&&&&
&&&&&&&&&&&&if(d==1){}
&&&&&&&&&&&&d--;
&&&&&&&&&&&}
publicclassShellSorter
publicvoidSort(int[]list)
for(inc=1;inc&=list.Length/9;inc=3*inc+1);
for(;inc&0;inc/=3)
for(inti=inc+1;i&=list.Li+=inc)
intt=list[i-1];
while((j&inc)&&(list[j-inc-1]&t))
list[j-1]=list[j-inc-1];
list[j-1]=t;
publicclassMainClass
publicstaticvoidMain()
int[]iArrary=newint[]{1,5,3,6,10,55,9,2,87,12,34,75,33,47};
ShellSortersh=newShellSorter();
sh.Sort(iArrary);
for(intm=0;m&=13;m++)
Console.WriteLine(&{0}&,iArrary[m]);
Console.ReadKey();
#include&stdio.h&
#include&math.h&
#define&MAXNUM&10
void&main()
&&&&void&shellSort(int&array[],int&n,int&t);//t为排序趟数
&&&&int&array[MAXNUM],i;
&&&&for(i=0;i&MAXNUM;i++)
&&&&&&&&scanf(&%d&,&array[i]);
&&&&shellSort(array,MAXNUM,int(log(MAXNUM+1)/log(2)));//排序趟数应为log2(n+1)的整数部分
&&&&for(i=0;i&MAXNUM;i++)
&&&&&&&&printf(&%d&&,array[i]);
&&&&printf(&\n&);
//根据当前增量进行插入排序
void&shellInsert(int&array[],int&n,int&dk)
&&&&int&i,j,
&&&&for(i=i&n;i++)//分别向每组的有序区域插入
&&&&&&&&temp=array[i];
&&&&&&&&for(j=i-(j&=i%dk)&&array[j]&j-=dk)//比较与记录后移同时进行
&&&&&&&&&&&&array[j+dk]=array[j];
&&&&&&&&if(j!=i-dk)
&&&&&&&&&&&&array[j+dk]=//插入
//计算Hibbard增量
int&dkHibbard(int&t,int&k)
&&&&return&int(pow(2,t-k+1)-1);
//希尔排序
void&shellSort(int&array[],int&n,int&t)
&&&&void&shellInsert(int&array[],int&n,int&dk);
&&&&int&i;
&&&&for(i=1;i&=t;i++)
&&&&&&&&shellInsert(array,n,dkHibbard(t,i));
//此写法便于理解，实际应用时应将上述三个函数写成一个函数。
voidCSortTest::ShellSort(int*data,unsignedintlen)
if(len&=1||data==NULL)
for(intdiv=len/2;div&=1;div/=2)
for(inti=i&i++)
for(intj=i;(data[j]&data[j-div])&&j&=0;j-=div)
swapInt(data+j,data+j-div);
//需要排序的数组
vararr:Array=[7,5,8,4,0,9];
varsmall://最小下标
for(vari:int=0;i&arr.i++){
for(varj:int=i+1;j&arr.length+1;j++){
if(arr[j]&arr[small]){
if(small!=i){
temp=arr[i];
arr[i]=arr[small];
arr[small]=
trace(arr[i]);
def&shell_sort(array)&&
&&gap&=&array.size&&
&&while&gap&&&1&&&&
&&&&gap&=&gap&/&2&&&&&&
&&&&(gap..array.size-1).each&do&|i|&&&&&&
&&&&&&j&=&i&&&&&&
&&&&&&while&j&&&0&&&&&&&&
&&&&&&&&array[j],&array[j-gap]&=&array[j-gap],&array[j]&if&array[j]&&=&array[j-gap]&&&&&&&&
&&&&&&&&j&-=&&gap&&&&&&
&&&&&&end&&&&
functionshell_sort(&$arr)
if(!is_array($arr))
$n=count($arr);
for($gap=floor($n/2);$gap&0;$gap=floor($gap/=2))
for($i=$$i&$n;++$i)
for($j=$i-$$j&=0&&$arr[$j+$gap]&$arr[$j];$j-=$gap)
$temp=$arr[$j];
$arr[$j]=$arr[$j+$gap];
$arr[$j+$gap]=$
defshell(arr):
l=len(arr)
whileh&l//3:
whileh&=1:
foriinrange(h,l):
whilej&=handarr[j]&arr[j-h]:
arr[j],arr[j-h]=arr[j-h],arr[j]
严蔚敏，吴伟民．数据结构（c语言版）：清华大学出版社，1997.4
．互动百科．[引用日期]
．数据结构[引用日期]
．维基百科[引用日期]
中国电子学会（Chinese Instit...
提供资源类型：内容矩阵乘法_百度百科
乘法是一种高效的算法可以把一些一维递推优化到log（ n )，还可以求路径方案等，所以更是一种应用性极强的算法。矩阵，是中的基本概念之一。一个m×n的矩阵就是m×n个数排成m行n列的一个数阵。由于它把许多数据紧凑的集中到了一起，所以有时候可以简便地表示一些复杂的模型。矩阵乘法看起来很奇怪，但实际上非常有用，应用也十分的广泛。
的矩阵，B=（
的矩阵，那么称
的矩阵C=（
)为矩阵A与B的乘积，记作
，其中矩阵C中的第
由定义可知，
1：当矩阵A的列数等于矩阵B的行数时，A与B可以相乘。
2：矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。
3：乘积C的第
等于矩阵A的第
行的元素与矩阵B的第
列对应元素乘积之和。
注意 矩阵乘法一般不满足交换律。即:
只有当矩阵A的列数与矩阵B的行数相等时A×B才有意义。一个m×n的a(m,n)左乘一个n×p的矩阵b(n,p)，会得到一个m×p的矩阵c(m,p)。左乘：又称前乘，就是乘在左边(即乘号前)，比如说,A左乘E即AE。
矩阵乘法满足，但不满足和约去律
一般的矩乘要结合快速幂才有效果。（基本上所有矩阵乘法都要用到快速幂的）
在计算机中，一个矩阵实际上就是一个二维数组。一个m行n列的矩阵与一个n行p列的矩阵可以相乘，得到的结果是一个m行p列的矩阵，其中的第i行第j列位置上的数为第一个矩阵第i行上的n个数与第二个矩阵第j列上的n个数对应相乘后所得的n个乘积之和。比如，下面的算式表示一个2行2列的矩阵乘以2行3列的矩阵，其结果是一个2行3列的矩阵。其中，结果矩阵的那个4（结果矩阵中第二（i）行第二（j)列）=
2（第一个矩阵第二(i)行第一列）*2（第二个矩阵中第一行第二(j)列）
0（第一个矩阵第二(i)行第二列）*1（第二个矩阵中第二行第二(j)列）：
#include&stdio.h&
int&p,&q,&k;
int&fun(float&A[][2],&float&B[][1]
&&&&float&C[2][1]&=&{&0&};&&&&
&&&&for&(p&=&0;&p&&&2;&++p)&&&&
&&&&{&&&&&&&&
&&&&for&(q&=&0;&q&&&1;&++q)&&&&&&&&
&&&&{&&&&&&&&&&&&
&&&&for&(k&=&0;&k&&&2;&++k)&&&&&&&&&&&&&&&&
&&&&C[p][q]&+=&A[p][k]&*&B[k][q];&&&&&&&&
&&&&for&(p&=&0;&p&&&2;&p++)&&&&
&&&&{&&&&&&&&
&&&&for&(q&=&0;&q&&&1;&q++)&&&&&&&&
&&&&{&&&&&&&&&&&&
&&&&printf(&%f&,&C[p][q]);&&&&&&&&&&&&
&&&&printf(&\n&);&&&&&&&&
&&&&return&0;
int&main()
&&&&float&A[2][2]&=&{&1,&1,&2,&1&},&B[2][1]&=&&&&{2,&1};&&&&
&&&&printf(&矩阵A*矩阵B为:\n&);&&&&//&计算两个矩阵相乘；以[2][2]*[2][1]为例&&&&
&&&&fun(A,&B);
&&&&system(&pause&);
&&&&return0;
程序运行结果示例：
一般矩乘的代码：function mul( a , b : Tmatrix ) : T
fillchar( c , sizeof( c ) , 0 );
for k:=0 to n do
for i:=0 to m do
for j:=0 to p do
inc( c[ i , j ] , a[ i , k ]*b[ k , j ] );
if c[ i , j ] & ra then c[ i , j ]:=c[ i , j ]
这里我们不介绍其它有关的知识，只介绍矩阵乘法和相关性质。
不要以为数学中的矩阵也是黑色屏幕上不断变化的绿色字符。在数学中，一个矩阵说穿了就是一个二维数组。一个n行m列的矩阵可以乘以一个m行p列的矩阵，得到的结果是一个n行p列的矩阵，其中的第i行第j列位置上的数等于前一个矩阵第i行上的m个数与后一个矩阵第j列上的m个数对应相乘后所有m个乘积的和。比如一下的例子中，算式所表示的是一个2行2列的矩阵与一个2行3列的矩阵相乘，所得的结果是一个2行3列的矩阵。所得矩阵中第2行第2列的“4”是2*2+0*1的和：
右面的算式则是一个1 x 3的乘以3 x 2的矩阵，得到一个1 x 2的矩阵：
矩阵乘法的两个重要性质： 一，矩阵乘法不满足；二，矩阵乘法满足。为什么矩阵乘法不满足交换律呢？这是由矩阵乘法定义决定的。因为矩阵AB=C，C的结果是由A的行与B的列相乘和的结果；而BA=D，D的结果是由B的行与A的列相乘和的结果。显然，得到的结果C和D不一定相等。同时，交换后两个矩阵有可能不能相乘。为什么它又满足结合律呢？假设你有三个矩阵A、B、C，那么(AB)C和A(BC)的结果的第i行第j列上的数都等于所有A(ik)*B(kl)*C(lj)的和（枚举所有的k和l）。
相关符号　以下是一个 4 × 3 ：
某矩阵 A 的第 i 行第 j 列，或 i,j位，通常记为 A[i,j] 或 Ai,j。在上述例子中 A[2,3]=7。
在C语言中，亦以 A[j] 表达。(值得注意的是，与一般矩阵的算法不同，在C中，&行&和&列&都是从0开始算起的)
此外 A = (aij)，意为 A[i,j] = aij 对于所有 i 及 j，常见于数学著作中。
一般环上构作的矩阵
给出一环 R，M(m,n, R) 是所有由 R 中元素排成的 m× n 矩阵的。若 m=n，则通常记以 M(n,R)。这些可加可乘 (请看下面)，故 M(n,R) 本身是一个环，而此环与左 R 模Rn 的环。
若 R 可置换， 则 M(n, R) 为一带的 R-。其上可以莱布尼茨公式定义 ：一个当且仅当其行列式在 R 内可逆。
除特别指出，一个矩阵多是矩阵或矩阵。
分块矩阵 是指一个大矩阵分割成“矩阵的矩阵”。举例，以下的矩阵
可分割成 4 个 2×2 的矩阵，矩阵将多种信号自由控制，将BSV液晶拼接跨屏显示。
此法可用于简化运算，简化，以及一些电脑应用如VLSI芯片设计等。
1.结合性 （AB)C=A(BC）．
2.对加法的分配性 （A+B)C=AC+BC，C(A+B）=CA+CB ．
3.对数乘的结合性 k(AB）=（kA)B =A(kB）．
4.关于转置 (AB)'=B'A'．
是相对其（由左上至右下）对称， 即是 ai,j=aj,i。
（或自）是相对其主对角线以复共轭方式对称， 即是 ai,j=a*j,i。
特普利茨矩阵在任意对角线上所有元素相对， 是 ai,j=ai+1,j+1。
所有列都是向量， 用于。
此外，还有，，条带矩阵
对角矩阵是仅在它的主对角线上有元素而其他位置上的元素全为零（即aij=
0或i≠j）的矩阵。如图为nXn的对角矩阵：
类似的是单位矩阵，但位于上的元素都是1，即a1=a2=......=an=1
条带矩阵是指与主对角线平行的位置上有非零元素而其他位置的元素全为零的矩阵来源　英文名Matrix（SAMND矩阵）。在中，用来表示统计数据等方面的各种有关联的数据。这个定义很好地解释了Matrix代码制造世界的数学逻辑基础。
成书于西汉末、东汉初的《》用分离法表示，得到了其。在消元过程中，使用的把某行乘以某一非零、从某行中减去另一行等运算技巧，相当于矩阵的。但当时并没有现在理解的矩阵概念，虽然它与现在的矩阵形式上相同，但在当时只是作为线性方程组的标准表示与处理方式。
的现代概念在19世纪逐渐形成。1801年德国数学家高斯（F.Gauss，）把一个线性变换的全部系数作为一个整体。1844年，德国数学家（F.Eissenstein，）讨论了“变换”（矩阵）及其乘积。1850年，英国数学家西尔维斯特（James Joseph Sylvester，）首先使用矩阵一词。1858年，英国数学家凯莱（A.Gayley，）发表《关于矩阵理论的研究报告》。他首先将矩阵作为一个独立的数学对象加以研究，并在这个主题上首先发表了一系列文章，因而被认为是矩阵论的创立者，他给出了现在通用的一系列定义，如两矩阵相等、、、两矩阵的和、一个数与一个矩阵的、两个矩阵的积、矩阵的逆、等。并且凯莱还注意到的是可结合的，但一般不可交换，且m*n矩阵只能用n*k矩阵去右乘。1854年，法国数学家埃米尔特（C.Hermite，）使用了“”这一术语，但他的正式定义直到1878年才由德国数学家费罗贝尼乌斯（F.G.Frohenius，）发表。1879年，费罗贝尼乌斯引入矩阵秩的概念。
至此，矩阵的体系基本上建立起来了。
制作图一般要遵循以下几个步骤：
①列出质量因素：
②把成对对因素排列成行和列，表示其对应关系
③选择合适的矩阵图类型
④在成对因素交点处表示其关系程度，一般凭经验进行定性判断，可分为三种：关系密切、关系较密切、关系一般（或可能有关系)，并用不同符号表示
⑤根据关系程度确定必须控制的重点因素
⑥针对重点因素作对策表。
给定n个点，m个操作，构造O(m+n)的算法输出m个操作后各点的位置。操作有平移、缩放、翻转和旋转
这里的操作是对所有点同时进行的。其中翻转是以为进行翻转（两种情况），旋转则以原点为中心。如果对每个点分别进行模拟，那么m个操作总共耗时O(mn)。利用乘法可以在O(m)的时间里把所有操作合并为一个矩阵，然后每个点与该矩阵相乘即可直接得出最终该点的位置，总共耗时O(m+n)。假设初始时某个点的坐标为x和y，下面5个矩阵可以分别对其进行平移、旋转、翻转和旋转操作。预先把所有m个操作所对应的矩阵全部乘起来，再乘以(x,y,1)，即可一步得出最终点的位置。
给定矩阵A，请快速计算出A^n（n个A相乘）的结果，输出的每个数都mod p。
由于矩阵乘法具有，因此A^4 = A * A * A * A = (A*A) * (A*A) = A^2 * A^2。我们可以得到这样的结论：当n为偶数时，A^n = A^(n/2) * A^(n/2)；当n为时，A^n = A^(n/2) * A^(n/2) * A （其中n/2取整）。这就告诉我们，计算A^n也可以使用二分快速求幂的方法。例如，为了算出A^25的值，我们只需要递归地计算出A^12、A^6、A^3的值即可。根据这里的一些结果，我们可以在计算过程中不断取模，避免高精度运算。
POJ3233[2]
题目大意：给定A，求A + A^2 + A^3 + ... + A^k的结果（两个矩阵相加就是对应位置分别相加）。输出的数据mod m。k&=10^9。
这道题两次二分，相当经典。首先我们知道，A^i可以二分求出。然后我们需要对整个题目的数据规模k进行二分。比如，当k=6时，有：
A + A^2 + A^3 + A^4 + A^5 + A^6 =(A + A^2 + A^3) + A^3*(A + A^2 + A^3)
应用这个式子后，规模k减小了一半。我们二分求出A^3后再递归地计算A + A^2 + A^3，即可得到原问题的答案。
题目大意：顺次给出m个置换，反复使用这m个置换对初始序列进行操作，问k次置换后的序列。m&=10, k&2^31。
首先将这m个置换“合并”起来（算出这m个置换的乘积），然后接下来我们需要执行这个置换k/m次（取整，若有余数则剩下几步模拟即可）。注意任意一个置换都可以表示成的形式。例如，将1 2 3 4置换为3 1 2 4，相当于下面的矩阵乘法：
置换k/m次就相当于在前面乘以k/m个这样的矩阵。我们可以二分计算出该矩阵的k/m次方，再乘以初始序列即可。做出来了别忙着高兴，得意之时就是你灭亡之日，别忘了最后可能还有几个置换需要模拟。
《》207页（2.1方法和模型，[例题5]细菌，版次不同可能页码有偏差）
大家自己去看看吧，书上讲得很详细。解题方法和上一题类似，都是用来表示操作，然后二分求最终状态。
给定n和p，求第n个Fibonacci数mod p的值，n不超过2^31
根据前面的一些思路，现在我们需要构造一个2 x 2的矩阵，使得它乘以(a,b)得到的结果是(b,a+b)。每多乘一次这个矩阵，这两个数就会多迭代一次。那么，我们把这个2 x 2的矩阵自乘n次，再乘以(0,1)就可以得到第n个Fibonacci数了。不用多想，这个2 x 2的矩阵很容易构造出来：
我们可以用上面的方法二分求出任何一个递推式的第n项，其对应的构造方法为：在右上角的(n-1)*(n-1)的小矩阵中的上填1，矩阵第n行填对应的，其它地方都填0。例如，我们可以用下面的矩阵乘法来二分计算f(n) = 4f(n-1) - 3f(n-2) + 2f(n-4)的第k项：
利用矩阵乘法求解线性递推关系的题目我能编出一卡车来。这里给出的例题是系数全为1的情况。
给定一个有向图，问从A点恰好走k步（允许重复经过边）到达B点的方案数mod p的值
把给定的图转为，即A(i,j)=1当且仅当存在一条边i-&j。令C=A*A，那么C(i,j)=ΣA(i,k)*A(k,j)，实际上就等于从点i到点j恰好经过2条边的路径数（枚举k为中转点）。类似地，C*A的第i行第j列就表示从i到j经过3条边的路径数。同理，如果要求经过k步的路径数，我们只需要二分求出A^k即可。
#include&&iostream&
#include&&cstdio&
#include&&algorithm&
#include&&cmath&
#include&&cstring&
#define&N&10
using&namespace&
const&int&mod&=&7777777;
typedef&long&long≪
struct&matrix{
&&LL&a[10][10];
matrix&multiply(matrix&x,matrix&y){
&&&matrix&
&&memset(temp.a,0,sizeof(temp.a));
&&&for(int&i=0;i&n;i++){
&&&&&&for(int&j=0;j&n;j++){
&&&&&&&&&for(int&k=0;k&n;k++){
&&&&&&&&&&&&temp.a[i][j]+=x.a[i][k]*y.a[k][j];
&&&&&&&&&&&&temp.a[i][j]=(temp.a[i][j])%
&&&&&&&&&}
&&&return&}
matrix&matmod(matrix&A,int&k){
&&&matrix&
&&&memset(res.a,0,sizeof&res.a);
&for(int&i=0;i&n;i++)&res.a[i][i]=1;
&while(k){
&&&&if(k&1)&res=multiply(res,A);
&&&&k&&=1;
&&&&A=multiply(A,A);
void&print(matrix&x){
&&&for(int&i=0;i&n;i++){
&&&&&&for(int&j=0;j&n;j++)
&&&&&&cout&&&&&&&x.a[i][j];puts(&&);
&&&printf(&---------------\n&);}
int&main(){
&&while(cin&&n&&k){
&&&&memset(origin.a,0,sizeof&origin.a);
&&&&origin.a[0][0]=1;
&&&&for(int&i=1;i&=n;i++){
&&&&&&origin.a[i][0]=1;
&&&&&&for(int&j=0;j&i;j++){
&&&&&&&&origin.a[i][0]+=origin.a[j][0];
&&&&&//&print(origin);
&&&&matrix&
&&&&memset(res.a,0,sizeof&res.a);
&&&&for(int&i=0;i&n-1;i++){
&&&&&&res.a[i][i+1]=1;
&&&&for(int&i=0;i&n;i++)&res.a[n-1][i]=1;
&&&&//print(res);
&&&&res=matmod(res,k-1);
&&&&LL&fans=0;
&&&&for(int&i=0;i&n;i++){
&&&&&&fans+=res.a[0][i]*origin.a[i][0];
&&&&&&fans%=
&&&&cout&&fans&&
&&return&0;
用1 x 2的多米诺骨牌填满M x N的矩形有多少种方案，M&=5，N&2^31，输出答案mod p的结果
我们以M=3为例进行讲解。假设我们把这个矩形横着放在电脑屏幕上，从右往左一列一列地进行填充。其中前n-2列已经填满了，第n-1列参差不齐。现在我们要做的事情是把第n-1列也填满，将状态转移到第n列上去。由于第n-1列的状态不一样（有8种不同的状态），因此我们需要分情况进行讨论。在图中，我把转移前8种不同的状态放在左边，转移后8种不同的状态放在右边，左边的某种状态可以转移到右边的某种状态就在它们之间连一根线。注意为了保证方案不重复，状态转移时我们不允许在第n-1列竖着放一个多米诺骨牌（例如左边第2种状态不能转移到右边第4种状态），否则这将与另一种转移前的状态重复。把这8种状态的转移关系画成一个有向图，那么问题就变成了这样：从状态111出发，恰好经过n步回到这个状态有多少种方案。比如，n=2时有3种方案，111-&011-&111、111-&110-&111和111-&000-&111，这与用多米诺骨牌覆盖3x2矩形的方案一一对应。这样这个题目就转化为了我们前面的例题8。
后面我写了一份此题的。你可以再次看到位运算的相关应用。
经典题目10
POJ2778[3]
题目大意是，检测所有可能的n位DNA串有多少个DNA串中不含有指定的病毒片段。合法的DNA只能由ACTG四个字符构成。题目将给出10个以内的病毒片段，每个片段长度不超过10。数据规模n&=2 000 000 000。
下面的讲解中我们以ATC,AAA,GGC,CT这四个病毒片段为例，说明怎样像上面的题一样通过构图将问题转化为例题8。我们找出所有病毒片段的前缀，把n位DNA分为以下7类：以AT结尾、以AA结尾、以GG结尾、以?A结尾、以?G结尾、以?C结尾和以??结尾。其中问号表示“其它情况”，它可以是任一字母，只要这个字母不会让它所在的串成为某个病毒的前缀。显然，这些分类是全集的一个划分（交集为空，为全集）。现在，假如我们已经知道了长度为n-1的各类DNA中符合要求的DNA个数，我们需要求出长度为n时各类DNA的个数。我们可以根据各类型间的转移构造一个边上带权的有向图。例如，从AT不能转移到AA，从AT转移到??有4种方法（后面加任一字母），从?A转移到AA有1种方案（后面加个A），从?A转移到??有2种方案（后面加G或C），从GG到??有2种方案（后面加C将构成病毒片段，不合法，只能加A和T）等等。这个图的构造过程类似于用做串匹配。然后，我们就把这个图转化成，让这个矩阵自乘n次即可。最后输出的是从??状态到所有其它状态的路径数总和。
题目中的数据规模保证前缀数不超过100，一次矩阵乘法是三方的，一共要乘log(n)次。因此这题总的是100^3 * log(n)，AC了。
最后给出第9题的代码供大家参考（今天写的，熟悉了一下C++的类和运算符重载）。为了避免大家看代码看着看着就忘了，我把这句话放在前面来说：
Matrix67原创，转贴请注明出处。
#include&&cstdio&
#define&SIZE&(1&&m)
#define&MAX_SIZE&32
using&namespace&
class&CMatrix
long&element[MAX_SIZE][MAX_SIZE];
void&setSize(int);
void&setModulo(int);
CMatrix&operator*&(CMatrix);
CMatrix&power(int);
void&CMatrix::setSize(int&a)
for&(int&i=0;&i&a;&i++)
for&(int&j=0;&j&a;&j++)
element[i][j]=0;
void&CMatrix::setModulo(int&a)
modulo&=&a;
CMatrix&CMatrix::operator*&(CMatrix&param)
product.setSize(size);
product.setModulo(modulo);
for&(int&i=0;&i&&i++)
for&(int&j=0;&j&&j++)
for&(int&k=0;&k&&k++)
product.element[i][j]+=element[i][k]*param.element[k][j];
product.element[i][j]%=
CMatrix&CMatrix::power(int&exp)
CMatrix&tmp&=&(*this)&*&(*this);
if&(exp==1)&return&*
else&if&(exp&&&1)&return&tmp.power(exp/2)&*&(*this);
else&return&tmp.power(exp/2);
int&main()
const&int&validSet[]={0,3,6,12,15,24,27,30};
long&n,&m,&p;
scanf(&%d%d%d&,&&n,&&m,&&p);
unit.setSize(SIZE);
for(int&i=0;&i&SIZE;&i++)
for(int&j=0;&j&SIZE;&j++)
if(&((~i)&j)&==&((~i)&(SIZE-1))&)
bool&isValid=
for&(int&k=0;&k&8;&k++)isValid=isValid||(i&j)==validSet[k];
unit.element[i][j]=isV
unit.setModulo(p);
printf(&%d&,&unit.power(n).element[SIZE-1][SIZE-1]&);
如：：{ F(n) } = { 1 1 } ^（n-2） * { 1 }
F(n-1) 1 0 1
传统算法：
若依定义来计算A和B的乘积C，则每计算C的一个元素C[i][j]，需要做n次乘法和n-1次加法。因此，算出矩阵C的个元素所需的计算时间为O(n3)
Strassen矩阵乘法：
T(n)=O(nlog7) =O(n2.81) 时间复杂度有了较大改进！
目前最好的计算时间上界是O(n2.376)
．百度文库[引用日期]
．POJ3233[引用日期]
．POJ2778[引用日期]}