+---+---+---+      +---+---+---+
| 1 | 2 | 3 |      | 8 | 7 | 6 |
+---+---+---+      +---+---+---+
| 4 | 5 | 6 |  ==> | 5 | 4 | 3 |
+---+---+---+      +---+---+---+
| 7 | 8 |   |      | 2 | 1 |   |
+---+---+---+      +---+---+---+

$ 8puzzle.py -f2
# 30
Number of states enqueued = 14754

#!/usr/bin/env python

import sys
from optparse import OptionParser
import math
from struct import pack
import heapq

class Solver:
    def __init__(self, n):
        self.N = n
        self.L = n * n

        self.GOAL = range(1, self.L)
        self.GOAL.append(0)

        # slide rules
        self.SR = {}
        for i in range(self.L):
            s = []
            if i - self.N >= 0:
                s.append(i - self.N)
            if (i % self.N) - 1 >= 0:
                s.append(i - 1)
            if (i % self.N) + 1 < self.N:
                s.append(i + 1)
            if i + self.N < self.L:
                s.append(i + self.N)
            self.SR[i] = s

        # queue
        self.queue = []
        self.enqueued = {}

        # verbose
        #self.verbose = 104999
        self.verbose = 8963

        # h
        self.w = 1
        self.h = self.heuristics

    def is_solvable(self, tiles):
        x = 0
        for p in range(len(tiles)):
            a = tiles[p]
            if a < 2 :
                continue
            for b in tiles[p:]:
                if b == 0:
                    continue
                if a > b:
                    x = x + 1
        return (x & 1) == 0

    def neighbors(self, tiles):
        n = []
        a = tiles.index(0)
        for b in self.SR[a]:
            n.append(self.swap(list(tiles), a, b))
        return n

    def swap(self, tiles, a, b):
        tiles[a], tiles[b] = tiles[b], tiles[a]
        return tiles

    def display(self, tiles):
        for i in range(self.L):
            if tiles[i]:
                print '%(n)#2d' % {'n': tiles[i]},
            else:
                print '  ',
            if i % self.N == self.N - 1:
                print

    def enqueue(self, state):
        (tiles, parent, h, g) = state

        if self.verbose > 0 and len(self.enqueued) % self.verbose == self.verbose - 1:
            print " -->", len(self.enqueued), g

        f = h * self.w + g;
        heapq.heappush(self.queue, (f, state))

    def dequeue(self):
        if len(self.queue) <= 0:
            return None
        (f, state) = heapq.heappop(self.queue)
        return state

    def heuristics(self, tiles):
        return 0;

    def manhattan(self, tiles):
        h = 0
        for i in range(self.L):
            n = tiles[i]
            if n == 0:
                continue
            h += int(abs(n - 1 - i) / self.N) + (abs(n - 1 - i) % self.N)
        return h

    def hamming(self, tiles):
        h = 0
        for i in range(self.L):
            n = tiles[i]
            if n > 0 and n - 1 != i:
                h += 1
        return h

    def solve(self, initial):
        if not self.is_solvable(initial):
            return None

        state = (initial, None, self.h(initial), 0);
        if initial == self.GOAL:
            return state

        self.enqueue(state)

        while True:
            state = self.dequeue()
            if (not state):
                break

            (tiles, parent, h, g) = state
            neighbors = self.neighbors(tiles)
            for n_tiles in neighbors:
                if n_tiles == self.GOAL:
                    return (n_tiles, state, 0, g + 1)

                packed = pack(self.L*'B', *n_tiles)
                if (packed in self.enqueued):
                    continue;
                self.enqueued[packed] = True                        

                n_state = (n_tiles, state, self.h(n_tiles), g + 1)
                self.enqueue(n_state)

def main(options, args):
    initial = []
    if args:
        for n in args:
            initial.append(int(n))
    else:
        initial = [8,7,6,5,4,3,2,1,0]

    solver = Solver(int(math.sqrt(len(initial))))

    solver.verbose = int(options.verbose)
    solver.w = float(options.weight)
    if int(options.function) == 1:
        solver.h = solver.hamming
    elif int(options.function) == 2:
        solver.h = solver.manhattan

    state = solver.solve(initial)
    if not state:
        print "No solution possible"
        return 1

    solution = []
    while state:
        (tiles, parent, h, g) = state
        solution.insert(0, tiles)
        state = parent

    n = 0
    for tiles in solution:
        print "#", n
        solver.display(tiles)
        print
        n += 1

    print "Number of states enqueued =", len(solver.enqueued)
    return 0

if __name__ == '__main__':
    parser = OptionParser(usage="usage: %prog [options] [tile] [tile] [tiles ...]")
    parser.add_option("-v", "--verbose", metavar="<level>",
            default=8963)
    parser.add_option("-f", "--function", metavar="<fid>",
            help="heuristics function. 1 for hamming, 2 for manhattan [default: None as breadth first]",
            default=0)
    parser.add_option("-w", "--weight", metavar="<n>",
            help="weighting of the heuristics function [default: 1]",
            default=1)
    (options, args) = parser.parse_args()

    sys.exit(main(options, args))

+----+----+----+----+       +----+----+----+----+
| 15 | 14 | 13 | 12 |       |  1 |  2 |  3 |  4 |
+----+----+----+----+       +----+----+----+----+
| 11 | 10 |  9 |  8 |       |  5 |  6 |  7 |  8 |
+----+----+----+----+  ==>  +----+----+----+----+
|  7 |  6 |  5 |  4 |       |  9 | 10 | 11 | 12 |
+----+----+----+----+       +----+----+----+----+
|  3 |  1 |  2 |    |       | 13 | 15 | 14 |    |
+----+----+----+----+       +----+----+----+----+

$ 8puzzle.py -f2 -w1.9 15 14 13 12 11 10 9 8 7 6 5 4 3 1 2 0
# 76
Number of states enqueued = 2812200

更新域名的API很简单，一个HTTP请求即可。API地址是: http://dynamic.wacao.com/api/plain.php，参数为，

• host – 主机名，FQDN为 ${host}.dynamic.wacao.com
• time – unixtime形式的请求时间，时间误差在正负5分钟内有效
• sign – 签名，格式为 sha1(${host}${time}${shared_key})
• ip – 可选。如果未提供IP地址则采用客户端请求的来源地址

其中host和shared_key需要我来提供。这里提供一个的host和shared_key给大家测试。testing d035cdac09dd866ed8f4a244567c4daf。域名为testing.dynamic.wacao.com.。

由于仅是一个HTTP请求，客户端很容易用各种语言实现。我自己用的是一个简单的shell脚本。

#!/bin/bash

function usage {
    echo "Usage: $0 {host} {shared_key}"
}

if test -z $1 || test -z $2
then
    usage
    exit 1
fi

HOST=$1
SHARED_KEY=$2
ENDPOINT="http://dynamic.wacao.com/api/plain.php"

TIME=`date +%s`
SIGN=`echo -n "${HOST}${TIME}${SHARED_KEY}" | sha1sum -t | awk '{print $1}'`
URL="${ENDPOINT}?host=${HOST}&time=${TIME}&sign=${SIGN}"
curl "$URL"

执行后立即能够解析，TTL为5秒。

$ update-dynamic-dns.sh testing d035cdac09dd866ed8f4a244567c4daf
ok. 58.33.69.77
$ host testing.dynamic.wacao.com.
testing.dynamic.wacao.com has address 58.33.69.77

我将这个脚本加到crontab里，每5分钟更新一次。

*/5 * * * * /usr/local/sbin/update-dynamic-dns.sh ${HOST} ${SHARED_KEY}

如果觉得testing.dynamic.wacao.com这样的域名不好看，而且你有自己的域名，可以想我一样，给自己的域名加一个CNAME。例如我把alcohol.swanpan.com做了一个CNAME指到alcohol.dynamic.wacao.com

;; ANSWER SECTION:
alcohol.swanpan.com.	86400	IN	CNAME	alcohol.dynamic.wacao.com.
alcohol.dynamic.wacao.com. 5	IN	A	58.33.69.77

这样我在各个地方都能用alcohol.swanpan.com这个域名访问家里的机器，方便用它穿墙。

想试试的朋友告诉我你要的host，我给你发送shared_key。

但是Gentoo在这里遇到两个小问题。

第一个问题，USB硬盘是可以热拔插，这样由于载入顺序的问题，每个硬盘设备名称可能会变化。例如这个机器自带一个读卡器，在没有外挂USB硬盘时启动后候设备名为/dev/sdb。之后插入USB硬盘，USB硬盘的设备名为/dev/sdc。但是如果挂着USB硬盘启动，这两个设备的设备名就正好反过来了。我希望是固定的设备名。

第二个问题，USB硬盘长时间不访问的时候不会自动停下来，这样既不省电也不利延长硬盘的寿命。我希望在不用的时候它可以休眠。

设备名的问题可以用udev的rules解决。我加了一个udev配置文件/etc/udev/rules.d/99-external-storages.rules。

KERNEL=="sd*", SUBSYSTEMS=="usb", ATTRS{idVendor}=="0bda", ATTRS{idProduct}=="0158", ATTRS{serial}=="20071114173400000", SYMLINK+="cardreader%n"
KERNEL=="sd*", SUBSYSTEMS=="usb", ATTRS{idVendor}=="1bcf", ATTRS{idProduct}=="0c31", ATTRS{serial}=="20090717090A", SYMLINK+="storage/neso%n"

这样给内置的读卡器添加了一个设备名的符号链接/dev/cardreader；给我的NESO 1T硬盘添加了设备名符号链接/dev/storage/neso。用固定名称访问设备的问题就解决了。

第二个问题稍微复杂些，一直没找到方便的方法。laptop-mode-tools也没能满足我的要求。一番搜索后找到sdparm可以用来控制USB硬盘，还有一段perl脚本用来调度sdparm。这样就可以满足我的需求了。脚本的原始出外我给忘了，这里我稍微修改了一点，增加对设备名符号链接的支持。

#!/usr/bin/perl -w
use File::Basename;
use Cwd 'abs_path';

$statfile = "/proc/diskstats";
die "$0: Cannot read $statfile\n" unless -r $statfile;

$| = 1;
($disk, $interval) = (@ARGV);

if (-l $disk) {
    $original_disk = $disk;
    while (-l $disk) {
        $disk = readlink $disk;
    }
    $disk = dirname($original_disk) . "/" . $disk;
    $disk = abs_path($disk);
}

$disk =~ s,/dev/,,;
print "$0: disk: $disk, interval: $interval\n";

$halted_data = $last_seen = '';
while (1) {
  open(STATUS, $statfile);
  ($_) = grep(/^\s+\d+\s+\d+\s+$disk\s/o, <STATUS>);
  close STATUS;

  if ($last_seen eq $_ && $halted_data ne $_) {
    print "Spinning down: $disk\n";
    system "sync";
    system "sdparm", "--command=stop", "/dev/$disk";
    $halted_data = $_;
  }
  $last_seen = $_;
  sleep $interval;
}

最后在启动脚本里加上

ebegin "    - Spindown USB HD"
nohup /usr/local/sbin/spindown-usbhd /dev/storage/neso 1200 >> /var/log/spindown-usbhd.log 2>&1 &
eend $?

好了，20分钟这块硬盘没有读写之后自动休眠。

public class Hello {
    public static void main(String[] args) {
        String s = "123";
        System.out.println(s);
        m1(s);
        System.out.println(s);

        int i = 123;
        System.out.println(i);
        m2(i);
        System.out.println(i);
    }

    private static void m1(String s) {
        s = "321";
    }

    private static void m2(int i) {
        i = 321;
    }
}

运行结果是什么？

#!/usr/bin/env python

import cookielib
import urllib
import urllib2
import time
import sys

def ddd_checkip():
        response = urllib2.urlopen("http://www.dragonsoft.net/checkip.php")
        return response.read()

def ddd_hello(opener):
        return opener.open("http://www.dns-diy.com/skin.aspx?skin=api")

def ddd_login(opener, username, password):
        request = urllib2.Request("https://www.dns-diy.com/api/login.aspx")
        params = urllib.urlencode({"username":username, 'password':password})
        request.add_data(params)
        return opener.open(request)

def ddd_logout(opener):
        request = urllib2.Request("http://www.dns-diy.com/api/logout.aspx?immediately=yes&invalidate=yes")
        return opener.open(request)

def ddd_update_rr(opener, id, name, type, data, aux, ttl):
        request = urllib2.Request("http://www.dns-diy.com/api/zone_rr_update.aspx")
        params = urllib.urlencode({"id":id, "rr_name":name, "rr_type":type, "rr_data":data, "rr_aux":aux, "rr_ttl":ttl})
        request.add_data(params)
        return opener.open(request)

#
#
#

DEBUG = 5
SLEEP_SECONDS = 600

USERNAME = "swanpan.com"
PASSWORD = "secure"
RR_ID    = "secure"
RR_NAME  = ""
RR_TYPE  = "A"
RR_DATA  = "127.0.0.1"
RR_AUX   = "0"
RR_TTL   = "5"

def ddd_process():
        if (DEBUG > 0):
                print "[%(time)s] updating %(host)s.%(zone)s (%(ip)s) ..." % \
                        {"time":time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), \
                        "host":RR_NAME, "zone":USERNAME, "ip":RR_DATA}

        opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookielib.CookieJar()))

        response = ddd_hello(opener)
        if (DEBUG > 5):
                print "HELLO"
                print response.read()

        response = ddd_login(opener, USERNAME, PASSWORD)
        if (DEBUG > 5):
                print "LOGIN"
                print response.read()

        response = ddd_update_rr(opener, RR_ID, RR_NAME, RR_TYPE, RR_DATA, RR_AUX, RR_TTL)
        if (DEBUG > 5):
                print "UPDATE"
                print response.read()

        response = ddd_logout(opener)
        if (DEBUG > 5):
                print "LOGOUT"
                print response.read()

        if (DEBUG > 0):
                print "[%(time)s] Finished!" % \
                        {"time":time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())}

while True:
        try:
                ip = ddd_checkip()
                if (RR_DATA != ip):
                        RR_DATA = ip
                        ddd_process()
        except:
                if (DEBUG > 4):
                        print "Unexpected error:", sys.exc_info()[0]

        time.sleep(SLEEP_SECONDS)

#! /bin/bash

SSPATH="$HOME/documents/pictures/screenshots"
SSDATE="$(date +%Y-%m-%d_%H-%M-%S)"
SSNAME="$SSPATH/$SSDATE.png"

if [ ! -d "$SSPATH" ]; then
        mkdir -p "$SSPATH"
fi

#sleep 10
import -window root "$SSNAME"