图片中给出的是无线电平均标号的定义，以及两条路笛卡尔乘积图的示意图，请你根据定义求出两条路的无限电平...

python
from functools import lru_cache
def solve_ladder(n, M, want_assignment=False):
    verts=[(r,c) for c in range(n) for r in range(2)] # columns order
    N=len(verts); d=n
    dist=[[abs(c1-c2)+(r1!=r2) for (r2,c2) in verts] for (r1,c1) in verts]
    # recursive: process labels 1..M, assigned list vertex per used label (dict tuple)
    # state: label, used mask, tuple of used assignments maybe need constraints with labels
    # Since constraints depend on previous labels values and vertices, need store assigned pairs.
    # backtracking with pruning
    assigned=[]
    usedmask=0
    # order vertices maybe extremes first
    allmask=(1<<N)-1
    # For each l and previous (p,vp), compute allowed v if distance cond.
    def ok_pair(l,v,p,vp):
        return dist[v][vp] + ((l+p+1)//2) >= n+1 # ceil
    best=None
    # symmetrical fix label 1 to one vertex? Since automorphisms, label 1 can be top-left? maybe only for existence? Not necessarily any vertex can be moved to one of orbits by dihedral. Ladder automorphism transposes rows and reverses columns; vertices in column c and n-1-c same orbit. Label1 likely must be near end? But no fix.
    from functools import lru_cache
    # Need memo on l, usedmask, assigned tuple? constraints depend assigned labels/positions. Can't compress.
    calls=0
    def rec(l, usedmask, ass):
        nonlocal best,calls
        calls+=1
        usedcnt=usedmask.bit_count()
        if usedcnt==N:
            best=ass
            return True
        if l>M:
            return False
        if usedcnt + (M-l+1) < N:
            return False
        # Try skipping l maybe, but only if enough left and maybe skip small to satisfy. But for minimizing M, skipping low labels common.
        # Try assigning l first? It might be necessary to use many labels.
        # Generate allowed vertices
        allowed=[]
        for v in range(N):
            if not (usedmask>>v)&1:
                good=True
                for p,vp in ass:
                    if not ok_pair(l,v,p,vp):
                        good=False; break
                if good:
                    allowed.append(v)
        # heuristic: if l small, assign restricted vertices. Try allowed ordered by extremes
        # But also skip option.
        # Branch choose assign l or skip. Use memo? 
        for v in allowed:
            if rec(l+1, usedmask| (1<<v), ass+((l,v),)):
                return True
        # skip
        if rec(l+1, usedmask, ass):
            return True
        return False
    res=rec(1,0,tuple())
    if want_assignment and res:
        return True, [(l, verts[v]) for l,v in best], calls
    return res,calls

for n in range(1,8):
    N=2*n
    for M in range(N, 5*n+5):
        ok,_=solve_ladder(n,M)
        if ok:
            print(n, M)
            break

python
for n in range(8,11):
    for M in range(2*n, 4*n):
        ok,calls=solve_ladder(n,M)
        if ok:
            print("n",n,"M",M,"calls",calls)
            break
        # print(n,M,calls)

python
for n in range(5,11):
    M=None
    for m in range(2*n,4*n):
        ok,calls=solve_ladder(n,m)
        if ok:
            M=m; break
    ok,ass,calls=solve_ladder(n,M,True)
    print("n",n,"M",M)
    # display grid with label or .
    grid=[["." for c in range(n)] for r in range(2)]
    for l,(r,c) in ass:
        grid[r][c]=str(l)
    for r in range(2):
        print(grid[r])
    print("used labels", [l for l,v in ass], "skipped", [i for i in range(1,M+1) if i not in [l for l,v in ass]])
    print()

python
import sympy as sp
n,M=sp.symbols('n M', integer=True, positive=True)
# max weighted sum: 2n labels from 1..M; assign largest 2n-4 to deg 3, next 4 to deg 2.
# Sum largest k labels up to M = k*(2M-k+1)/2
k=2*n-4
sum_largest_k=k*(2*M-k+1)/2
sum_next4=4*(2*M-k-4+1)/2 # labels M-k-3..M-k
max_weight=3*sum_largest_k+2*sum_next4
req=(3*n-2)*(2*n-1)
sp.expand(max_weight), sp.solve_univariate_inequality(sp.expand(max_weight-req)>=0,M)

python
import sympy as sp
n,M=sp.symbols('n M')
k=2*n-4
sum_largest_k=k*(2*M-k+1)/2
sum_next4=4*(2*M-k-4+1)/2
max_weight=sp.expand(3*sum_largest_k+2*sum_next4)
req=sp.expand((3*n-2)*(2*n-1))
print(max_weight)
print(req)
print(sp.expand(max_weight-req))
print(sp.solve(sp.Eq(max_weight-req,0),M))

python
def pair_sum_lower_ladder(n):
    verts=[(r,c) for r in range(2) for c in range(n)]
    total=0
    count=0
    from itertools import combinations
    for u,v in combinations(range(2*n),2):
        r1,c1=verts[u]; r2,c2=verts[v]
        t=abs(c1-c2)+(r1!=r2)
        total+=2*n+1-2*t
        count+=1
    return total
for n in range(2,11):
    total=pair_sum_lower_ladder(n)
    print(n,total, total/(2*n-1))
    # max sum labels with span M = n*(2*M-2*n+1). Lower yields
    import math
    M=math.ceil((total/(2*n-1)/n +2*n-1)/2) # solve n(2M-2n+1)>=total/(2n-1)
    print("Mlb",M, "formula", math.ceil((8*n-8)/3))

python
from itertools import combinations
def packing_ladder(n,r): # mutual distance >= r+1
    verts=[(row,c) for c in range(n) for row in range(2)]
    N=2*n
    conflict=[[False]*N for _ in range(N)]
    for i in range(N):
        for j in range(i+1,N):
            d=abs(verts[i][1]-verts[j][1])+(verts[i][0]!=verts[j][0])
            if d<=r: conflict[i][j]=conflict[j][i]=True
    # brute force max independent in conflict for small n
    best=0
    bestset=None
    for mask in range(1<<N):
        # too large for 20 maybe ok 1M
        if mask.bit_count()<=best: continue
        ok=True
        for i in range(N):
            if (mask>>i)&1:
                # check only j>i
                for j in range(i+1,N):
                    if (mask>>j)&1 and conflict[i][j]:
                        ok=False; break
                if not ok: break
        if ok:
            best=mask.bit_count(); bestset=mask
    return best
for r in range(1,8):
    print("r",r, [packing_ladder(n,r) for n in range(2,13)])

python
import math
def q_packing_lb(n):
    vals=[]
    for r in range(1,n+1):
        vals.append(n-r-math.ceil(n/r))
    return max(0,max(vals)), vals
for n in range(1,31):
    q,_=q_packing_lb(n)
    print(n,q, "Mlb",2*n+q)

python
# Re-define more efficient solver with candidates and memo.
from functools import lru_cache
def feasible_ladder(n, M, find=False, time_limit_nodes=1000000):
    verts=[(r,c) for c in range(n) for r in range(2)]
    N=2*n
    dist=[[abs(c1-c2)+(r1!=r2) for (r2,c2) in verts] for (r1,c1) in verts]
    # precompute allowed mask for label l given previous label p and vertex vp: vertices v compatible
    comp={}
    for l in range(1,M+1):
        for p in range(1,l):
            req=n+1-((l+p+1)//2)
            # need dist>=req
            masks=[]
            for vp in range(N):
                mask=0
                for v in range(N):
                    if v!=vp and dist[v][vp]>=req:
                        mask |= 1<<v
                masks.append(mask)
            comp[(p,l)]=masks
    full=(1<<N)-1
    # symmetry for first used

python
results={}
for n in range(1,31):
    # use previous for n small? 
    lb=2*n+q_packing_lb(n)[0]
    for M in range(lb, 4*n): # upper hopefully
        ok,nodes,ass=feasible_ladder(n,M,time_limit_nodes=1000000)
        if ok is None:
            print("timeout",n,M,nodes)
            break
        if ok:
            results[n]=M
            print(n,M,"q",M-2*n,"lbq",q_packing_lb(n)[0],"nodes",nodes)
            break
    if n not in results:
        print("not found n",n)
        break

python
for n in [12,13,14,15,20,25]:
    M=results[n]
    ok,nodes,ass=feasible_ladder(n,M,find=True,time_limit_nodes=1000000)
    print("n",n,"M",M,"p",3*n-M,"skips",[i for i in range(1,M+1) if i not in [l for l,v in ass]][:50])
    grid=[["." for c in range(n)] for r in range(2)]
    for l,(r,c) in ass:
        grid[r][c]=l
    for r in range(2):
        print(" ".join(f"{grid[r][c]:2}" for c in range(n)))
    print()

python
from functools import lru_cache
def feasible_deficits(t,n,find=False):
    verts=[(r,c) for c in range(n) for r in range(2)]
    N=2*n
    dist=[[abs(c1-c2)+(r1!=r2) for (r2,c2) in verts] for (r1,c1) in verts]
    # assign deficits t,t-1,...? Larger more restrictive. Deficit labels are values 1..t.
    order=list(range(t,0,-1))
    # Fix largest deficit t maybe at left/right? Use symmetry row0 maybe, and column <= middle?
    ass={}
    used=0
    nodes=0
    def rec(idx, usedmask, assignments):
        nonlocal nodes
        nodes+=1
        if idx==len(order): return assignments
        x=order[idx]
        # candidate all vertices not used meeting constraints with assigned deficits
        candidates=[]
        for v in range(N):
            if usedmask>>v &1: continue
            ok=True
            for y,vy in assignments.items():
                req=(x+y)//2 +1 # floor((x+y)/2)+1
                if dist[v][vy] < req:
                    ok=False;break
            if ok: candidates.append(v)
        # symmetry for first
        if idx==0:
            candidates=[v for v in candidates if verts[v][0]==0 and verts[v][1]<= (n-1)//2]
        # order by near center/ends?
        candidates.sort(key=lambda v: abs(verts[v][1]-(n-1)/2))
        for v in candidates:
            res=rec(idx+1, usedmask|1<<v, {**assignments,x:v})
            if res is not None: return res
        return None
    res=rec(0,0,{})
    if find and res is not None:
        return True,{x:verts[v] for x,v in res.items()},nodes
    return res is not None,nodes

def W_deficits(t):
    for n in range(1,100):
        ok,_=feasible_deficits(t,n)
        if ok:
            return n
for t in range(1,16):
    w=W_deficits(t)
    print(t,w)

python
import math
def W(t):
    if t<=0: return 0
    if t==1: return 1
    if t==2: return 2
    if t%2==0:
        s=t//2
        return 2*s*s-2*s+3
    else:
        s=(t-1)//2
        return 2*s*s+2
def A(n):
    t=0
    while W(t+1)<=n:
        t+=1
    return t
for n in range(1,31):
    M=max(2*n,3*n-A(n)-1)
    print(n,A(n),M)

python
for n in range(3,200):
    a=A(n)
    b=math.floor(1+math.sqrt(2*n-4))
    if a!=b:
        print("mismatch",n,a,b,W(a),W(a+1)); break
else:
    print("all ok")

python
# implement a reliable coordinate construction manually maybe find one for t up to 9 using previous function but trust? Need not.
def find_deficit_assignment(t):
    n=W(t)
    ok,assign,nodes=feasible_deficits(t,n,find=True)
    return assign
for t in range(1,10):
    assign=find_deficit_assignment(t)
    print("t",t,"W",W(t),assign)
    # sort by deficit
    # grid
    n=W(t)
    grid=[["." for _ in range(n)] for _ in range(2)]
    for x,(r,c) in assign.items():
        grid[r][c]=str(x)
    for row in grid: print(" ".join(f"{v:>2}" for v in row))
    print()

python
import itertools, math
def min_path_weight(t):
    best=10**9; bestp=None
    for perm in itertools.permutations(range(1,t+1)):
        s=sum((perm[i]+perm[i+1])//2 for i in range(t-1))
        if s<best:
            best=s;bestp=perm
    return best,bestp
for t in range(1,9):
    print(t, min_path_weight(t), "W-1", W(t)-1)

python
def construction_perm(t):
    if t==1: return [1]
    if t==2: return [2,1] # or
    # pattern for t:
    # for t=5 min path [3,2,1,4,5]
    # for t=7 [5,2,1,4,3,6,7]
    # for t=9 [7,2,1,4,3,6,5,8,9] maybe
    perm=[t-2 if t%2==1 else t-1]  # endpoint largest-1 for odd, t-1 for even
    # Actually for t=9 start7; yes t-2.
    # then pairs 2,1,4,3,6,5,... up to t-3? 
    for k in range(2,t-1,2):
        perm.extend([k,k-1])
    # append remaining high endpoints?
    if t%2==1:
        # after k up to t-3,t-4, append t-1?, t?
        # for t=9, loop k=2,4,6,8? range(2,8,2)=2,4,6 -> [2,1,4,3,6,5], append8,9
        perm.extend([t-1,t])
    else:
        # for t=8, start7, loop k=2,4,6? append [2,1,4,3,6,5], append8
        perm.append(t)
    return perm
def coords_from_perm(perm, extra_even=True):
    cols=[0]
    rows=[0]
    for i in range(len(perm)-1):
        gap=(perm[i]+perm[i+1])//2
        # for even t maybe add extra gap to first? Need check
        cols.append(cols[-1]+gap)
        rows.append(1-rows[-1]) # alternate
    if len(perm)%2==0 and extra_even:
        # add one to all after some position maybe after label1? easiest add to last coordinate? increases gaps for pairs across cut.
        pass
    return {x:(rows[i],cols[i]) for i,x in enumerate(perm)}
def check_deficits(coords):
    xs=list(coords)
    ok=True; bad=[]
    for i,x in enumerate(xs):
        for y in xs[i+1:]:
            r1,c1=coords[x]; r2,c2=coords[y]
            d=abs(c1-c2)+(r1!=r2)
            req=(x+y)//2+1
            if d<req:
                ok=False; bad.append((x,y,d,req))
    width=max(c for r,c in coords.values())-min(c for r,c in coords.values())+1
    return ok,width,bad[:10]
for t in range(3,12):
    perm=construction_perm(t)
    coords=coords_from_perm(perm)
    print(t,perm,check_deficits(coords))

python
def rec_coords(t):
    # Returns coords for deficits 1..t width W(t)
    if t==1:
        return {1:(0,0)}
    if t==2:
        return {2:(0,0),1:(1,1)}
    if t==3:
        return {3:(0,0),2:(1,2),1:(0,3)}
    if t==4:
        return {4:(0,0),3:(1,3),2:(0,5),1:(1,6)}
    old=rec_coords(t-2)
    # put t at left col 0 row0; shift old by a? put t-1 at right W(t)-1 row? 
    # try a=t-2 or t-1; rows maybe flip depending.
    width_old=max(c for r,c in old.values())+1
    for a in range(0,2*t):
        for row_t in [0,1]:
            for row_r in [0,1]:
                # maybe flip old rows or not
                for flip in [0,1]:
                    coords={t:(row_t,0), t-1:(row_r,W(t)-1)}
                    for x,(r,c) in old.items():
                        coords[x]=(r^flip,c+a)
                    ok,width,bad=check_deficits(coords)
                    if ok and width==W(t):
                        return coords
    raise Exception("no")
for t in range(1,13):
    coords=rec_coords(t)
    print("t",t,"width",check_deficits(coords)[1], "W",W(t), "coords", sorted(coords.items()))
    # print grid

python
def walk_positions(t):
    col=0; row=0
    coords={0:(row,col)}
    for i in range(1,t+1):
        # change row every time
        row=1-row
        step=i-1
        if i==1: sign=1
        else:
            block=(i-2)//2
            sign=1 if block%2==0 else -1
        col += sign*step
        coords[i]=(row,col)
    minc=min(c for r,c in coords.values())
    coords={i:(r,c-minc) for i,(r,c) in coords.items()}
    width=max(c for r,c in coords.values())+1
    return coords,width
def check_deficits_subset(coords, include0=False):
    xs=[x for x in coords if include0 or x>0]
    bad=[]
    for idx,x in enumerate(xs):
        for y in xs[idx+1:]:
            r1,c1=coords[x]; r2,c2=coords[y]
            d=abs(c1-c2)+(r1!=r2)
            # condition for deficits x,y, both low if positive: req=floor((x+y)/2)+1
            req=(x+y)//2 +1
            if d<req:
                bad.append((x,y,d,req))
    return bad
for t in range(1,13):
    coords,width=walk_positions(t)
    low_coords={i:coords[i] for i in range(1,t+1)}
    minc=min(c for r,c in low_coords.values())
    low_coords={i:(r,c-minc) for i,(r,c) in low_coords.items()}
    low_width=max(c for r,c in low_coords.values())+1
    print("t",t,"allwidth",width,"lowwidth",low_width,"W",W(t),"bad",check_deficits_subset(low_coords)[:3],"coords",coords)

python
def feasible_deficits_with0(t,n,find=False):
    vals=list(range(t, -1, -1)) # include 0
    verts=[(r,c) for c in range(n) for r in range(2)]
    N=2*n
    dist=[[abs(c1-c2)+(r1!=r2) for (r2,c2) in verts] for (r1,c1) in verts]
    def req(x,y):
        return (x+y)//2 + 1
    def rec(idx, usedmask, ass):
        if idx==len(vals): return ass
        x=vals[idx]
        candidates=[]
        for v in range(N):
            if usedmask>>v &1: continue
            ok=True
            for y,vy in ass.items():
                if dist[v][vy] < req(x,y):
                    ok=False;break
            if ok: candidates.append(v)
        if idx==0:
            candidates=[v for v in candidates if verts[v][0]==0 and verts[v][1]<= (n-1)//2]
        candidates.sort(key=lambda v: abs(verts[v][1]-(n-1)/2))
        for v in candidates:
            res=rec(idx+1,usedmask|1<<v,{**ass,x:v})
            if res is not None: return res
        return None
    res=rec(0,0,{})
    if find and res is not None:
        return True,{x:verts[v] for x,v in res.items()}
    return res is not None
def W0(t):
    for n in range(1,100):
        if feasible_deficits_with0(t,n):
            return n
for t in range(1,9):
    print(t,W0(t), "W", W(t))

python
for t in range(1,9):
    n=W0(t)
    ok,assign=feasible_deficits_with0(t,n,find=True)
    print("t",t,"n",n,assign)
    grid=[["." for _ in range(n)] for _ in range(2)]
    for x,(r,c) in assign.items():
        grid[r][c]=str(x)
    for row in grid: print(" ".join(f"{v:>2}" for v in row))
    print()

python
import itertools, math
def path_weight(perm):
    return sum((perm[i]+perm[i+1])//2 for i in range(len(perm)-1))
def equality_paths(s, limit=20):
    target=math.ceil(s*s/2 - s +1)
    paths=[]
    for perm in itertools.permutations(range(1,s+1)):
        if path_weight(perm)==target:
            paths.append(perm)
            if len(paths)>=limit: break
    return target,paths
for s in [4,6]:
    target,paths=equality_paths(s,1000)
    print("s",s,"target",target,"num_sample",len(paths))
    for p in paths[:10]:
        # construct cols gaps minimal, rows alternating
        cols=[0]
        for i in range(s-1): cols.append(cols[-1]+(p[i]+p[i+1])//2)
        rows=[i%2 for i in range(s)]
        coords={p[i]:(rows[i],cols[i]) for i in range(s)}
        bad=check_deficits(coords)[2]
        print(p,bad[:3])
    print()

python
def coords_from_perm_with_extra(perm, extra_after_label=None):
    cols=[0]; rows=[0]
    for i in range(len(perm)-1):
        gap=(perm[i]+perm[i+1])//2
        if extra_after_label is not None and perm[i]==extra_after_label:
            gap+=1
        cols.append(cols[-1]+gap)
        rows.append(1-rows[-1])
    return {x:(rows[i],cols[i]) for i,x in enumerate(perm)}
def even_perm(t):
    return construction_perm(t)
for t in [4,6,8,10]:
    perm=even_perm(t)
    coords=coords_from_perm_with_extra(perm,extra_after_label=1)
    print(t, perm, check_deficits(coords)[:2], check_deficits(coords)[2][:5])

python
def coords_from_perm_alt(perm):
    cols=[0]; rows=[0]
    for i in range(len(perm)-1):
        cols.append(cols[-1]+(perm[i]+perm[i+1])//2)
        rows.append(1-rows[-1])
    return {x:(rows[i],cols[i]) for i,x in enumerate(perm)}
for perm in [(5,2,3,1,4),(7,4,5,2,3,1,6),(9,6,7,4,5,2,3,1,8)]:
    coords=coords_from_perm_alt(list(perm))
    print(perm, path_weight(perm), check_deficits(coords)[:2], check_deficits(coords)[2][:5])

python
def coords_even(t):
    perm=even_perm(t)
    return coords_from_perm_with_extra(perm,extra_after_label=1)
def perm_odd(t):
    # t odd >=3
    perm=[t]
    # pairs (t-3,t-2), descending by 2 down to (2,3)
    for a in range(t-3,1,-2):
        perm.extend([a,a+1])
    perm.extend([1,t-1])
    return perm
def coords_odd(t):
    return coords_from_perm_alt(perm_odd(t))
def possible_zero(coords,t):
    width=check_deficits(coords)[1]
    positions=[]
    for c in range(width):
        for r in [0,1]:
            if (r,c) in coords.values(): continue
            ok=True
            for i,(ri,ci) in coords.items():
                d=abs(c-ci)+(r!=ri)
                req=i//2 +1 # floor(i/2)+1
                if d<req:
                    ok=False;break
            if ok: positions.append((r,c))
    return positions
for t in range(3,11):
    coords=coords_odd(t) if t%2 else coords_even(t)
    print("t",t,"width",check_deficits(coords)[1],"zero options",possible_zero(coords,t)[:10])
    # print coords
    print(sorted(coords.items(), key=lambda kv: kv[1][1]))

python
def req_for_def(x,y):
    # x,y are deficits: label n-x and n-y. For y negative means high label.
    # condition: dist + ceil((2n - x - y)/2) >= n+1
    # ceil(n - (x+y)/2)= n - floor((x+y)/2)
    # req = floor((x+y)/2)+1. If <=1, distinct vertices automatically at dist>=1.
    return max(1, (x+y)//2 + 1)
def feasible_special(t,n,find=False):
    vals=list(range(t, -(t-2)-1, -1)) # t,t-1,...,-(t-2)
    # order maybe positives first descending then 0 then negatives descending? 
    # To search, use sorted by absolute/positive? Use vals as t..negative
    verts=[(r,c) for c in range(n) for r in range(2)]
    N=2*n
    dist=[[abs(c1-c2)+(r1!=r2) for (r2,c2) in verts] for (r1,c1) in verts]
    def rec(idx, usedmask, ass):
        if idx==len(vals): return ass
        x=vals[idx]
        candidates=[]
        for v in range(N):
            if usedmask>>v & 1: continue
            ok=True
            for y,vy in ass.items():
                if dist[v][vy] < req_for_def(x,y):
                    ok=False;break
            if ok:candidates.append(v)
        if idx==0:
            candidates=[v for v in candidates if verts[v][0]==0 and verts[v][1]<= (n-1)//2]
        candidates.sort(key=lambda v: abs(verts[v][1]-(n-1)/2))
        for v in candidates:
            res=rec(idx+1, usedmask|1<<v, {**ass,x:v})
            if res is not None:return res
        return None
    res=rec(0,0,{})
    if find and res is not None:
        return True,{x:verts[v] for x,v in res.items()}
    return res is not None
for t in range(1,9):
    n= max(W0(t),2*t-1)
    # actually width W?
    print("t",t,"W0",W0(t),"2t-1",2*t-1, "feas at W0", feasible_special(t,W0(t)))
    if feasible_special(t,W0(t)):
        ok,assign=feasible_special(t,W0(t),find=True)
        print(assign)

python
def special_extend_from_coords(coords,t):
    # coords positives, place 0 and negatives greedily maybe using known zero then search
    # We'll search with fixed positives for remaining 0,-1,...
    width=check_deficits(coords)[1]
    verts=[(r,c) for c in range(width) for r in range(2)]
    N=2*width
    used=set(coords.values())
    vals=[0]+[-j for j in range(1,t-1)]
    ass={**coords}
    # sort maybe 0, -1...
    def rec(idx,ass,used):
        if idx==len(vals): return ass
        x=vals[idx]
        cands=[]
        for v in verts:
            if v in used: continue
            ok=True
            for y,vy in ass.items():
                d=abs(v[1]-vy[1])+(v[0]!=vy[0])
                if d<req_for_def(x,y):
                    ok=False;break
            if ok: cands.append(v)
        # prefer near label1/zero
        cands.sort(key=lambda rc: (abs(rc[1]-width/2), rc[0]))
        for v in cands:
            res=rec(idx+1,{**ass,x:v}, used|{v})
            if res: return res
        return None
    return rec(0,ass,used)
for t in range(3,11):
    coords=coords_odd(t) if t%2 else coords_even(t)
    ass=special_extend_from_coords(coords,t)
    print("t",t, "width",check_deficits(coords)[1])
    print(sorted(ass.items(), key=lambda kv: kv[1][1]))
    print()