與MSSQL比較進修MYSQL的心得（二）--顯示寬度。本站提示廣大學習愛好者：（與MSSQL比較進修MYSQL的心得（二）--顯示寬度）文章只能為提供參考，不一定能成為您想要的結果。以下是與MSSQL比較進修MYSQL的心得（二）--顯示寬度正文
我們先來看看整數型數據類型的寬度規模
創立一個表
CREATE TABLE tb_emp( id BIGINT(1))
id字段的數據類型為BIGINT(1)，留意到前面的數字1，這表現的是該數據類型指定的顯示寬度，指定可以或許顯示的數值中數字的個數。
例如，假定聲明一個INT類型的字段 YEAR INT(4)
該聲明指明，在year字段中的數據普通只顯示4位數字的寬度。
在SQLSERVER裡是會報錯的
CREATE TABLE abc
(id INT(11))
新聞 2716，級別 16，狀況 1，第 1 行
第 1 個列、參數或變量: 不克不及對數據類型 int 指定列寬。
顯示寬度和數據類型的取值規模是有關的。顯示寬度只是指明MYSQL最年夜能夠顯示的數字個數，數值的位數小於指定的寬度時會有空格填充
假如拔出了年夜於顯示寬度的值，只需該值不跨越該類型整數的取值規模，數值仍然可以拔出，並且能顯示出來。
例如，向year字段拔出一個數值19999，當應用select查詢的時刻，MYSQL顯示的將是完全帶有5位數字的19999，而不是4位數字的值
假如不指定顯示寬度，則MYSQL為每品種型指定默許的寬度值
tips：顯示寬度只用於顯示，其實不能限制取值規模和占用空間，例如：INT(3)會占用4個字節的存儲空間，而且許可的最年夜值也不會是999，而是INT整型所許可的最年夜值。
20153293720" />我們在圖片中可以看到，我們有兩條火車道路：白色和藍色。車站位於某些坐標點上，所以我們很輕易就可以算出它們之間的間隔。每個車站有一個以它的起點定名的貨車，和當我們勝利投遞它可以獲得的分數嘉獎。
如今，假定我們的貨車能跑3千米遠。白色道路上的火車可以把 A 車站的火車送到它的 起點 E (5點分數)，藍色道路上的火車可以輸送貨車 C(10點分數)，然後輸送貨車 B(5點分數)。 可以獲得最高分20分。
狀況表現
我們把火車的地位，和火車所走的間隔和每一個車站的貨車表格叫做一個成績狀況。 轉變這些值我們獲得的還是雷同的成績，然則參數變了。我們可以看到每次我們挪動 一列火車，我們的成績就演化到一個分歧的子成績。為了算出最好的挪動計劃，我們 必需遍歷這些狀況然後基於這些狀況作出決議計劃。讓我們開端把。
我們將從界說火車道路開端。由於這些道路不是直線，所以圖是最好的表現辦法。
import math
from decimal import Decimal
from collections import namedtuple, defaultdict
class TrainRoute:
def __init__(self, start, connections):
self.start = start
self.E = defaultdict(set)
self.stations = set()
for u, v in connections:
self.E[u].add(v)
self.E[v].add(u)
self.stations.add(u)
self.stations.add(v)
def next_stations(self, u):
if u not in self.E:
return
yield from self.E[u]
def fuel(self, u, v):
x = abs(u.pos[0] - v.pos[0])
y = abs(u.pos[1] - v.pos[1])
return Decimal(math.sqrt(x * x + y * y))
TrainRoute 類完成了一個異常根本的有向圖，它把極點作為車站存在一個聚集中，把車站間 的銜接存在一個字典中。請留意我們把 (u, v) 和 (v, u) 兩條邊都加上了，由於火車可以 向前向後挪動。
在 next_stations 辦法中有一個風趣器械，在這裡我應用了一個很酷的 Python 3 的特征yield from。這許可一個生成器 可以委派到別的一個生成器或許迭代器中。由於每個車站都映照到一個車站的聚集，我們只 須要迭代它便可以了。
讓我們來看一下 main class:
TrainWagon = namedtuple('TrainWagon', ('dest', 'value'))
TrainStation = namedtuple('TrainStation', ('name', 'pos', 'wagons'))
class TrainEmpire:
def __init__(self, fuel, stations, routes):
self.fuel = fuel
self.stations = self._build_stations(stations)
self.routes = self._build_routes(routes)
def _build_stations(self, station_lines):
# ...
def _build_routes(self, route_lines):
# ...
def maximum_route_score(self, route):
def score(state):
return sum(w.value for (w, s) in state.wgs if w.dest == s.name)
def wagon_choices(state, t):
# ...
def delivered(state):
# ...
def next_states(state):
# ...
def backtrack(state):
# ...
# ...
def maximum_score(self):
return sum(self.maximum_route_score(r) for r in self.routes)
我省略了一些代碼，然則我們可以看到一些風趣的器械。兩個 定名元組 將會贊助堅持我們的數據整潔而簡略。main class 有我們的火車可以或許運轉的最長的間隔，燃料， 和道路和車站這些參數。maximum_score 辦法盤算每條道路的分數的總和，將成為處理成績的 接口，所以我們有：
靜態計劃
我曾經測驗考試說明了靜態計劃若何高效地搜刮狀況空間的症結，和基於已有的狀況停止最優的決議計劃。 我們有一個界說了火車的地位，火車殘剩的燃料，和每一個貨車的地位的狀況空間——所以我們曾經可以表現初始狀況。
我們如今必需斟酌在每一個車站的每種決議計劃。我們應當裝載一個貨車然後把它送到目標地嗎？ 假如我們鄙人一個車站發明了一個更有價值的貨車怎樣辦？我們應當把它送歸去或許照樣往前 挪動？或許照樣不帶著貨車挪動？
很明顯，這些成績的謎底是誰人可使我們取得更多的分數的誰人。為了獲得謎底，我們必需求出 一切能夠的情況下的前一個狀況和後一個狀況的值。固然我們用求分函數 score 來求每一個狀況的值。
def maximum_score(self):
return sum(self.maximum_route_score(r) for r in self.routes)
State = namedtuple('State', ('s', 'f', 'wgs'))
wgs = set()
for s in route.stations:
for w in s.wagons:
wgs.add((w, s))
initial = State(route.start, self.fuel, tuple(wgs))
從每一個狀況動身都有幾個選擇：要末帶著貨車挪動到下一個車站，要末不帶貨車挪動。逗留不動不會進入一個新的 狀況，由於甚麼器械都沒轉變。假如以後的車站有多個貨車，挪動它們中的一個都將會進入一個分歧的狀況。
def wagon_choices(state, t):
yield state.wgs # not moving wagons is an option too
wgs = set(state.wgs)
other_wagons = {(w, s) for (w, s) in wgs if s != state.s}
state_wagons = wgs - other_wagons
for (w, s) in state_wagons:
parked = state_wagons - {(w, s)}
twgs = other_wagons | parked | {(w, t)}
yield tuple(twgs)
def delivered(state):
return all(w.dest == s.name for (w, s) in state.wgs)
def next_states(state):
if delivered(state):
return
for s in route.next_stations(state.s):
f = state.f - route.fuel(state.s, s)
if f < 0:
continue
for wgs in wagon_choices(state, s):
yield State(s, f, wgs)
next_states 是一個以一個狀況為參數然後前往一切這個狀況能達到的狀況的生成器。 留意它是若何在一切的貨車都挪動到了目標地後停滯的，或許它只進入到那些燃料依然足夠的狀況。wagon_choices 函數能夠看起來有點龐雜，其實它僅僅前往那些可以從以後車站到下一個車站的貨車聚集。
如許我們就有了完成靜態計劃算法須要的一切器械。我們從初始狀況開端搜刮我們的決議計劃，然後選擇 一個最有戰略。看！初始狀況將會演化到一個分歧的狀況，這個狀況也會演化到一個分歧的狀況！ 我們正在設計的是一個遞歸算法：
明顯每一個下一個狀況都將做這一系列的異樣的工作。我們的遞歸函數將會在燃料用盡或許一切的貨車都被輸送都目標地了時停滯。
max_score = {}
def backtrack(state):
if state.f <= 0:
return state
choices = []
for s in next_states(state):
if s not in max_score:
max_score[s] = backtrack(s)
choices.append(max_score[s])
if not choices:
return state
return max(choices, key=lambda s: score(s))
max_score[initial] = backtrack(initial)
return score(max_score[initial])
完成靜態計劃戰略的最初一個圈套：在代碼中，你可以看到我應用了一個 max_score 字典， 它現實上緩存著算法閱歷的每個狀況。如許我們就不會反復一遍又一遍地遍歷我們的我們早就曾經 閱歷過的狀況的決議計劃。
當我們搜刮狀況空間的時刻，一個車站能夠會達到屢次，這個中的一些能夠會招致雷同的燃料，雷同的貨車。 火車怎樣達到這裡的沒緊要，只要在誰人時刻做的決議計劃有影響。假如我們我們盤算過誰人狀況一次而且保留了 成果，我們就不在須要再搜刮一遍這個子空間了。
假如我們沒有效這類記憶化技巧，我們會做年夜量完整雷同的搜刮。 這平日會招致我們的算法很難高效地處理我們的成績。
總結
Train Empire 供給了一個絕佳的的例子，以展現靜態計劃是若何在有堆疊子成績的成績做出最優決議計劃。 Python 壯大的表達才能再一次讓我們很簡略地就可以把設法主意完成，而且寫出清楚且高效的算法。
完全的代碼在 contest repository。
