PUZZLEUP 2014

newkid

lastwinner 发表于 2014-10-31 00:33
没看错，我就是想知道策略如何设计，但又不想去看之前你给出的sql结果——因为里面不容易看出策略

这个X=21的理想树形是设计不出来的，我已经证明了。既然不可能，就无所谓什么策略。
X=20形状不是这样。我是用代码弄出来的，去掉了上面的推论1(即允许回头)，这样就构造出来了。

newkid

lastwinner 发表于 2014-10-31 00:32
这种机械的活儿做起来太累了啊

如果旋转、翻转后重合的形状只能算一种：

WITH t AS (SELECT LEVEL N FROM DUAL CONNECT BY LEVEL<=5)
,t2 AS (
SELECT S,SUBSTR(S,N)||SUBSTR(S,1,N-1) S2
   FROM (SELECT REPLACE(SYS_CONNECT_BY_PATH(N,','),',') S  FROM t
          WHERE LEVEL=5
          CONNECT BY NOCYCLE PRIOR N<>N
        ),t
)
SELECT DISTINCT MIN(s2)
  FROM (SELECT s,s2 FROM t2 UNION ALL SELECT s,REVERSE(s2) FROM t2)
GROUP BY s
;

14325
12543
13524
13245
14235
12534
13254
12345
12453
12435
13425
12354

12 rows selected.

〇〇

newkid 发表于 2014-10-31 02:20
如果旋转、翻转后重合的形状只能算一种：

WITH t AS (SELECT LEVEL N FROM DUAL CONNECT BY LEVEL

高级

peter1166

使用了 newkid 的思路改写， 不能算其他方法。

WITH T AS (
SELECT REPLACE(SYS_CONNECT_BY_PATH(N,','),',','') S
FROM (SELECT LEVEL N FROM DUAL CONNECT BY LEVEL <= 5 )
WHERE LEVEL = 5
CONNECT BY NOCYCLE LEVEL <= 5 AND N <> PRIOR N
)

SELECT DISTINCT S1 FROM T
MODEL
DIMENSION BY (S)
MEASURES (S AS S1)
RULES (
  S1[S] = S1[REVERSE(CV())]
);

〇〇

newkid 发表于 2014-10-31 02:20
如果旋转、翻转后重合的形状只能算一种：

WITH t AS (SELECT LEVEL N FROM DUAL CONNECT BY LEVEL

每个结果都是1开头，能否去掉

newkid

〇〇 发表于 2014-10-31 17:43
每个结果都是1开头，能否去掉

你什么意思？
从哪个点出发都一样，都是等价的。我用了LEAST所以全部从1点出发。有什么不对？

newkid

野花要的X=20的分配策略，原来竟是如此简单！

平均分成五组，每组四个点。
取第一组，从点1开始。令点1指向第二组所有的点，点2指向第三组所有的点，...四个组刚好分配给四个点。
对其他组做同样的分配动作。

WITH p AS
(SELECT LEVEL p,CEIL(LEVEL/4) g,ROW_NUMBER() OVER(PARTITION BY CEIL(LEVEL/4) ORDER BY LEVEL) rn
   FROM DUAL
CONNECT BY LEVEL<=20)
,g AS (
       SELECT p from_p,to_p
         FROM (
       SELECT p1.*,p2.p to_p,DENSE_RANK() OVER(PARTITION BY p1.g ORDER BY p2.g) rnk
         FROM p p1,p p2
        WHERE p1.g<>p2.g
              )
       WHERE rn=rnk
) ----- 至此分配完毕
SELECT from_p,COUNT(DISTINCT to_p) FROM (
SELECT g1.from_p
      ,g2.to_p
  FROM g g1, g g2
WHERE g1.to_p=g2.from_p
UNION ALL
SELECT * FROM g
)
GROUP BY from_p;

    FROM_P COUNT(DISTINCTTO_P)
---------- -------------------
         1                  20
         2                  20
         3                  20
         4                  20
         5                  20
         6                  20
         7                  20
         8                  20
         9                  20
        10                  20
        11                  20
        12                  20
        13                  20
        14                  20
        15                  20
        16                  20
        17                  20
        18                  20
        19                  20
        20                  20

20 rows selected.
        

WITH p AS
(SELECT LEVEL p,CEIL(LEVEL/4) g,ROW_NUMBER() OVER(PARTITION BY CEIL(LEVEL/4) ORDER BY LEVEL) rn
   FROM DUAL
CONNECT BY LEVEL<=20)
,g AS (
       SELECT p from_p,to_p
         FROM (
       SELECT p1.*,p2.p to_p,DENSE_RANK() OVER(PARTITION BY p1.g ORDER BY p2.g) rnk
         FROM p p1,p p2
        WHERE p1.g<>p2.g
              )
       WHERE rn=rnk
) ----- 至此分配完毕      
SELECT from_p,SUM(in_cnt),SUM(out_cnt)
  FROM (
SELECT from_p,0 in_cnt,COUNT(*) out_cnt FROM g GROUP BY from_p
UNION ALL
SELECT to_p,COUNT(*),0 FROM g GROUP BY to_p
)
GROUP BY from_p
ORDER BY 1;

    FROM_P SUM(IN_CNT) SUM(OUT_CNT)
---------- ----------- ------------
         1           4            4
         2           4            4
         3           4            4
         4           4            4
         5           4            4
         6           4            4
         7           4            4
         8           4            4
         9           4            4
        10           4            4
        11           4            4
        12           4            4
        13           4            4
        14           4            4
        15           4            4
        16           4            4
        17           4            4
        18           4            4
        19           4            4
        20           4            4

20 rows selected.

newkid

上面是校验，分配结果简单得很：

WITH p AS
(SELECT LEVEL p,CEIL(LEVEL/4) g,ROW_NUMBER() OVER(PARTITION BY CEIL(LEVEL/4) ORDER BY LEVEL) rn
   FROM DUAL
CONNECT BY LEVEL<=20)
,g AS (
       SELECT p from_p,to_p
         FROM (
       SELECT p1.*,p2.p to_p,DENSE_RANK() OVER(PARTITION BY p1.g ORDER BY p2.g) rnk
         FROM p p1,p p2
        WHERE p1.g<>p2.g
              )
       WHERE rn=rnk
)
SELECT * FROM g ORDER BY 1,2

    FROM_P       TO_P
---------- ----------
         1          5
         1          6
         1          7
         1          8
         2          9
         2         10
         2         11
         2         12
         3         13
         3         14
         3         15
         3         16
         4         17
         4         18
         4         19
         4         20
         5          1
         5          2
         5          3
         5          4
         6          9
         6         10
         6         11
         6         12
         7         13
         7         14
         7         15
         7         16
         8         17
         8         18
         8         19
         8         20
         9          1
         9          2
         9          3
         9          4
        10          5
        10          6
        10          7
        10          8
        11         13
        11         14
        11         15
        11         16
        12         17
        12         18
        12         19
        12         20
        13          1
        13          2
        13          3
        13          4
        14          5
        14          6
        14          7
        14          8
        15          9
        15         10
        15         11
        15         12
        16         17
        16         18
        16         19
        16         20
        17          1
        17          2
        17          3
        17          4
        18          5
        18          6
        18          7
        18          8
        19          9
        19         10
        19         11
        19         12
        20         13
        20         14
        20         15
        20         16

80 rows selected.

lastwinner

newkid 发表于 2014-10-31 02:20
如果旋转、翻转后重合的形状只能算一种：

WITH t AS (SELECT LEVEL N FROM DUAL CONNECT BY LEVEL

其实就等价于固定从某个点开始的连法数量

lastwinner

newkid 发表于 2014-11-1 02:19
野花要的X=20的分配策略，原来竟是如此简单！

平均分成五组，每组四个点。

我当时对着你ASCII树状图琢磨半天也没想出策略，后来发现，你那图是21个点的，囧啊