23201421-PTA第7，8次大作業總結-第三次Bolg

23201421-孙彬發表於2024-06-29

前言：
這兩次的大作業相對於前兩次的作業來說，難度大了很多很多，雖然是前兩次的迭代，但是需要考慮的問題比前兩次大了非常多，同時沒有給具體的測試點，錯了也不知道錯在哪，相對於前兩次除錯難度大了很多，同時測試點透過的難度也大了很多。
設計與分析：
第七次pta作業題目：
智慧家居是在當下家庭中越來越流行的一種配置方案，它透過物聯網技術將家中的各種裝置（如音影片裝置、照明系統、窗簾控制、空調控制、安防系統、數字影院系統、影音伺服器、影櫃系統、網路家電等）連線到一起，提供家電控制、照明控制、電話遠端控制、室內外遙控、防盜報警、環境監測、暖通控制、紅外轉發以及可程式設計定時控制等多種功能和手段。與普通家居相比，智慧家居不僅具有傳統的居住功能，兼備建築、網路通訊、資訊家電、裝置自動化，提供全方位的資訊互動功能。請根據如下要去設計一個智慧家居強電電路模擬系統。以下題目介紹中加粗的部分為本次迭代在“家居強電電路模擬程式-2”的基礎上增加的功能要求。
1、控制裝置
本題模擬的控制裝置包括：開關、分檔調速器、連續調速器、互斥開關。
開關：包括0和1兩種狀態。
開關有兩個引腳，任意一個引腳都可以是輸入引腳（接往電源端），而另一個則是輸出引腳（接網接地端）。開關狀態為0時，無論輸入電位是多少，輸出引腳電位為0。當開關狀態為1時，輸出引腳電位等於輸入電位。
互斥開關：
解釋
互斥開關有3個引腳：1個是彙總引腳，另兩個是分支引腳。

開關電路示意圖如圖1所示，左邊是彙總引腳，編號為1；右邊兩個是分支引腳，右上的輸出引腳為2，右下輸出引腳為3。圖中1、2、3引腳均可以是輸入引腳，當1為輸入引腳時，2、3引腳為輸出引腳；1為輸出引腳時，2、3引腳為輸入引腳。

互斥開關只有兩種狀態：開關接往上面的2號引腳、接往下面的3號引腳。開關每次只能接通其中一個分支引腳，而另一個分支引腳處於斷開狀態。

互斥開關的預設狀態為1、2引腳接通，1、3引腳斷開。

圖1中所示的互斥開關可以反過來接入電路，即彙總引腳接往接地端，兩個分支引腳接往電源端。

圖1 互斥開關
為避免短路，互斥開關設定了限流電阻，12引腳之間預設電阻為5，13引腳之間預設電阻為10。
分檔調速器
按檔位調整，常見的有3檔、4檔、5檔調速器，檔位值從0檔-2（3/4）檔變化。本次迭代模擬4檔調速器，每個檔位的輸出電位分別為0、0.3、0.6、0.9倍的輸入電壓。
連續調速器
沒有固定檔位，按位置比例得到檔位引數，數值範圍在[0.00-1.00]之間，含兩位小數。輸出電位為檔位引數乘以輸入電壓。
所有調速器都有兩個引腳，一個固定的輸入（引腳編號為1）、一個輸出引腳（引腳編號為2）。當輸入電位為0時，輸出引腳輸出的電位固定為0，不受各類開關調節的影響。
開關、調速器的初始狀態/檔位為0。
調速器的輸入引腳編號為1，輸出引腳編號為2。
除互斥開關外，其他控制裝置的電阻為 0。
2、受控裝置
本題模擬的受控裝置包括：燈、風扇。兩種裝置都有兩根引腳，透過兩根引腳電壓的電壓差驅動裝置工作。
燈有兩種工作狀態：亮、滅。在亮的狀態下，有的燈會因引腳電位差的不同亮度會有區別。
風扇在接電後有兩種工作狀態：停止、轉動。風扇的轉速會因引腳間電位差的不同而有區別。
本次迭代模擬兩種燈具。
白熾燈：
亮度在0~200lux（流明）之間。
電位差為0-9V時亮度為0,其他電位差按比例，電位差10V對應50ux，220V對應200lux，其他電位差與對應亮度值成正比。白熾燈超過220V。
日光燈：
亮度為180lux。
只有兩種狀態，電位差為0時，亮度為0，電位差不為0，亮度為180。
本次迭代模擬兩種風扇。
吊扇：
工作電壓區間為80V-150V，對應轉速區間為80-360轉/分鐘。80V對應轉速為80轉/分鐘，150V對應轉速為360轉/分鐘，超過150V轉速為360轉/分鐘（本次迭代暫不考慮電壓超標的異常情況）。其他電壓值與轉速成正比，輸入輸出電位差小於80V時轉速為0。
落地扇：
工作電壓區間為 80V-150V，對應轉速區間為 80-360 轉/分鐘；[80V,100V) 對應轉速為 80 轉/分鐘；[100,120)V 對應轉速為 160 轉/分鐘；[120,140)V 對應轉速為 260 轉/分鐘；大於等於 140V 轉速為 360 轉/分鐘（本次迭代暫不考慮電壓超標的異常情況）。

本次迭代模擬一種受控窗簾：
受控窗簾的電路符號為S，其最低工作電壓為50V，電壓達到或超過50V，窗簾即可正常工作，不考慮室外光照強度和室內空間大小等因素，窗簾受室內燈光的光照強度控制。
解釋
當電路中所有燈光的光照強度總和在[0,50)lux範圍內，窗簾全開；
在[50,100)lux範圍內，窗簾開啟比例為0.8；
在[100,200)lux範圍內，窗簾開啟比例為0.6；
在[200,300)lux範圍內，窗簾開啟比例為0.4；
在[300,400)lux範圍內，窗簾開啟比例為0.2；
在400lux及以上範圍內，窗簾關閉。
當電壓低於50V，窗簾不工作，預設為全開狀態。
如果電路中沒有燈或者燈全部關閉，光照強度為0，窗簾處於全開狀態。
受控裝置電阻：白熾燈的電阻為 10，日光燈的電阻為 5，吊扇的電阻為 20，落地扇的電阻為 20，窗簾電阻為15。
3、輸入資訊
1）輸入裝置資訊
分別用裝置識別符號K、F、L、B、R、D、A、H、S分別表示開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、落地扇、互斥開關、受控窗簾。
裝置標識用識別符號+編號表示，如K1、F3、L2等。
引腳格式：裝置標識-引腳編號，例如：K1-1標識編號為1的開關的輸入引腳。
開關、分檔調速器、連續調速器的輸入引腳編號為1，輸出引腳編號為2。
受控裝置的兩個引腳編號分別為1、2。
互斥開關的引腳編號已經在互斥開關的介紹部分說明。
約束條件：
不同裝置的編號可以相同。
同種裝置的編號可以不連續。
裝置資訊不單獨輸入，包含在連線資訊中。
2）輸入連線資訊
一條連線資訊佔一行，用[]表示一組連線在一起的裝置引腳，引腳與引腳之間用英文空格" "分隔。
格式："["+引腳號+" "+引腳號+"]"
例如：[K1-1 K3-2]表示K1的1引腳，K3的2引腳連線在一起。
約束條件：
不考慮調速器串聯到其他調速器的情況。
考慮各類裝置的並聯接入。例如，K1 的輸出接到 L2 的輸入，L2 的輸出再接其他裝置屬於串聯接線。K1 的輸出接到 L2 的輸出，同時 K1 的輸入接到 L2 的輸入，這種情況屬於並聯。
本次迭代的連線資訊不單獨輸入，包含線上路資訊中。

3）輸入控制裝置調節資訊
開關、互斥開關調節資訊格式：

+裝置標識K+裝置編號，例如：#K2，代表切換K2開關的狀態。

+裝置標識H+裝置編號，例如：#H2，代表切換H2互斥開關的狀態。

分檔調速器的調節資訊格式：

+裝置標識F+裝置編號+"+" 代表加一檔，例如：#F3+，代表F3輸出加一檔。

+裝置標識F+裝置編號+"-" 代表減一檔，例如：#F1-，代表F1輸出減一檔。

連續調速器的調節資訊格式：

+裝置標識L+裝置編號+":" +數值代表將連續調速器的檔位設定到對應數值，例如：#L3:0.6，代表L3輸出檔位引數0.6。

4）電源接地標識：
VCC，電壓220V，GND，電壓0V。沒有接線的引腳預設接地，電壓為0V。

5）輸入串聯電路資訊
一條串聯電路佔一行，串聯電路由按從靠電源端到接地端順序依次輸入的 n 個連線資訊組成，連線資訊之間用英文空格" "分隔。
串聯電路資訊格式：
"#T"+電路編號+":"+連線資訊+" "+連線資訊+...+" "+連線資訊
例如：#T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT] 一個串聯電路的第一個引腳是 IN，代表起始端，靠電源。最後一個引腳是 OUT，代表結尾端，靠接地。
約束條件：
解釋
不同的串聯電路資訊編號不同。

輸入的最後一條電路資訊必定是總電路資訊，總電路資訊的起始引腳是 VCC，結束引腳是 GND。

連線資訊中的引腳可能是一條串聯或並聯電路的 IN 或者 OUT。例如：

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT OUT]

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT M2-IN] [M2-OUT OUT]

6）輸入並聯電路資訊
一條並聯電路佔一行，並聯電路由其包含的幾條串聯電路組成，串聯電路標識之間用英文空格" "分隔。
格式：
"#M"+電路編號+":"+”[”+串聯電路資訊+" "+....+" "+串聯電路資訊+”]”
例如：#M1:[T1 T2 T3]
該例宣告瞭一個並聯電路，由 T1、T2、T3 三條串聯電路並聯而成，三條串聯電路的 IN 短接在一起構成 M1 的 IN，三條串聯電路的 OUT 短接在一起構成 M1 的 OUT。
約束條件：
本次迭代不考慮並聯電路中包含並聯電路的情況。
本題不考慮輸入電壓或電壓差超過220V的情況。
輸入資訊以end為結束標誌，忽略end之後的輸入資訊。
本題中的並聯資訊所包含的串聯電路的資訊都在並聯資訊之前輸入，不考慮亂序輸入的情況。
只要不因短路而造成無窮大的電流燒壞電路(如電路中的部分短接)，都是合理情況，在測試點的考慮範圍之內。會造成無窮大的電流的短路本次迭代不考慮。
本次迭代考慮多個並聯電路串聯在一起的情況。
本題考慮一條串聯電路中包含其他串聯電路的情況。例如：

T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]

本例中T1\T2兩條串聯電路T3的一個部分，本題考慮這種型別的輸入。

4、輸出資訊：
按開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、互斥開關、受控窗簾的順序依次輸出所有裝置的狀態或引數。每個裝置一行。同類裝置按編號順序從小到大輸出。
輸出格式：
解釋
@裝置標識+裝置編號+":" +裝置引數值（控制開關的檔位或狀態、燈的亮度、風扇的轉速，只輸出值，不輸出單位）
連續調速器的檔位資訊保留兩位小數，即使小數為0，依然顯示兩位小數.00。
開關狀態為0（開啟）時顯示turned on，狀態為1（合上）時顯示closed
如：
@K1:turned on
@B1:190
@L1:0.60
互斥開關顯示1、2引腳的接通狀態，接通時顯示closed，斷開時顯示turned on。
如：
@H1:turned on
受控窗簾顯示窗簾開啟的百分比，如：
@S1:80%

5、家居電路模擬系列所有題目的預設規則：
1）當計算電壓值等數值的過程中，最終結果出現小數時，用截尾規則去掉小數部分，只保留整數部分。為避免精度的誤差，所有有可能出現小數的數值用double型別儲存並計算，不要作下轉型資料型別轉換，例如電壓、轉速、亮度等，只有在最後輸出時再把計算結果按截尾規則，捨棄尾數，保留整數輸出。
2）所有連線資訊按電路從電源到接地的順序依次輸入，不會出現錯位的情況。電源VCC一定是第一個連線的第一項，接地GND一定是最後一個連線的後一項。
3）連線資訊如果只包含兩個引腳，靠電源端的引腳在前，靠接地端的在後。
4）調速器的輸入端只會直連VCC，不會接其他裝置。整個電路最多隻有連線在電源上的一個調速器，且不包含在並聯單路中。

6、家居電路模擬系列1-4題目後續迭代設計：
1）電路結構變化：
迭代1：只有一條線路，所有元件串聯
迭代2：線路中包含一個並聯電路
迭代3：線路中包含多個串聯起來的並聯電路
迭代4：並聯電路之間可能出現包含關係
電路結構變化示意圖見圖1。
2）計算方式的變化
迭代1只包含1個受控元件，不用計算電流，之後的電路計算要包含電流、電阻等電路引數。
3）電路元件的變化
每次迭代會增加1-2個新的電路元件。

圖1：電路結構示意圖
設計建議：
1、電路裝置類：描述所有電路裝置的公共特徵。
2、受控裝置類、控制裝置類：對應受控、控制裝置
3、串聯電路類：一條由多個電路裝置構成的串聯電路，也看成是一個獨立的電路裝置
4、並聯電路類：繼承電路裝置類，也看成是一個獨立的電路裝置
其他類以及類的屬性、方法自行設計。

圖2：建議設計類圖
輸入樣例1:
在這裡給出一組輸入。例如：
解釋

T1:[IN H1-1] [H1-2 D2-1] [D2-2 OUT]

T2:[IN H1-1] [H1-3 D1-1] [D1-2 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 B2-1] [B2-2 OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T3:[VCC K2-1] [K2-2 M1-IN] [M1-OUT M2-IN] [M2-OUT GND]

K1

K2

end
輸出樣例1:
在這裡給出相應的輸出。例如：
解釋
@K1:closed
@K2:closed
@K3:turned on
@B1:87
@B2:0
@D1:0
@D2:262
@H1:closed
輸入樣例2:
在這裡給出一組輸入。例如：
解釋

T1:[IN D2-1] [D2-2 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 B2-1] [B2-2 OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T3:[VCC K2-1] [K2-2 M1-IN] [M1-OUT M2-IN] [M2-OUT GND]

K1

K2

end
輸出樣例2:
在這裡給出相應的輸出。例如：
解釋
@K1:closed
@K2:closed
@K3:turned on
@B1:87
@B2:0
@D1:0
@D2:262
@H1:closed
輸入樣例3:
在這裡給出一組輸入。例如：
解釋

T1:[IN K1-1] [K1-2 B2-1] [B2-2 OUT]

T2:[IN K2-1] [K2-2 R1-1] [R1-2 OUT]

M1:[T1 T2]

T3:[VCC K3-1] [K3-2 M1-IN] [M1-OUT S1-1] [S1-2 GND]

K1

K2

K3

end
輸出樣例3:
在這裡給出相應的輸出。例如：
解釋
@K1:closed
@K2:closed
@K3:closed
@B2:71
@R1:180
@S1:40%
輸入樣例4:
在這裡給出一組輸入。例如：
解釋

T1:[IN K2-1] [K2-2 D2-1] [D2-2 OUT]

T2:[IN K3-1] [K3-2 D1-1] [D1-2 OUT]

T3:[VCC K1-1] [K1-2 T1-IN] [T1-OUT T2-IN] [T2-OUT GND]

K1

K2

K3

end
輸出樣例4:
在這裡給出相應的輸出。例如：
解釋
@K1:closed
@K2:closed
@K3:closed
@D1:200
@D2:200
輸入樣例5:
在這裡給出一組輸入。例如：

T3:[VCC B2-1] [B2-2 K1-1] [K1-2 S1-1] [S1-2 H1-1] [H1-2 GND]

K1

end
輸出樣例5:
在這裡給出相應的輸出。例如：
解釋
@K1:closed
@B2:95
@H1:closed
@S1:80%
設計類圖：

程式碼如下：
import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Iterator;
import java.util.Collections;
import java.util.*;

public class Main{
public static void main(String[] args)
{
LinkedList eidlist = new LinkedList<>();
LinkedList neweidlist = new LinkedList<>();
LinkedList connectlist = new LinkedList<>();
LinkedHashMap<String,Equipment> emap = new LinkedHashMap<>();
LinkedList controllist = new LinkedList<>();
LinkedList binglist = new LinkedList<>();
LinkedList chuanlist = new LinkedList<>();
Scanner in = new Scanner(System.in);
//輸入
while(true)
{
LinkedList elist = new LinkedList<>();
String newin=in.nextLine();
if(newin.equals("end"))
break;
if(newin.startsWith("#T"))
{
Pattern pat = Pattern.compile("#(T\d+)😦.)");
Matcher mat = pat.matcher(newin);
mat.find();
String sname = mat.group(1);
eidlist.add(sname);
//System.out.println(sname);
Equipment s = new Series(sname);
Pattern pat1 = Pattern.compile("(\w+)-(\w+)");
Matcher mat1 = pat1.matcher(newin);
while(mat1.find())
{
connectlist.add(mat1.group(0));
String id = mat1.group(1);
//System.out.println(id);
if(id.startsWith("H"))
{
elist.add(mat1.group(0));
eidlist.add(mat1.group(0));
((Series)s).selist.add(mat1.group(0));
continue;
}
elist.add(id);
eidlist.add(id);
((Series)s).selist.add(id);
}
emap.put(sname,s);
chuanlist.add((Series)s);
}
else if(newin.startsWith("#M"))
{
Pattern pat = Pattern.compile("#(M\d+)😦.)");
Matcher mat = pat.matcher(newin);
mat.find();
String pname = mat.group(1);
eidlist.add(pname);
Equipment p = new Parallel(pname);
int index = newin.indexOf("😊;
String str1 = newin.substring(index+1,newin.length()-1);
String ps = str1.replaceAll("[\[\]]","");
String[] pa = ps.split("\s+");
for(int i=0;i<pa.length;i++)
{
((Parallel)p).pelist.add(pa[i]);
}
emap.put(pname,p);
binglist.add((Parallel)p);
}
else if(newin.startsWith("#K")||newin.startsWith("#L")||newin.startsWith("#F")||newin.startsWith("#H"))
{
controllist.add(newin);
}
}
Iterator it=eidlist.iterator();
while (it.hasNext()){
String str=it.next();
if (!neweidlist.contains(str)){
neweidlist.add(str);
//System.out.println(str);
}
}
for(int i=0;i<chuanlist.size();i++)
{
LinkedList neweidlist1=new LinkedList<>();
Iterator it1=chuanlist.get(i).selist.iterator();
while (it1.hasNext()){
String str=it1.next();

            if (!neweidlist1.contains(str)){
                neweidlist1.add(str);
                //System.out.println(str);
            }
        }
        chuanlist.get(i).selist=neweidlist1;
    }
    for(int i=0;i<binglist.size();i++)
    {
        LinkedList<String> neweidlist2=new LinkedList<>();
        Iterator<String> it2=binglist.get(i).pelist.iterator();
        while (it2.hasNext()){
            String str=it2.next();

            if (!neweidlist2.contains(str)){
                neweidlist2.add(str);

//System.out.println(str);
}
}
binglist.get(i).pelist=neweidlist2;
}
for(String eid:neweidlist)
{
if(eid.matches("K\d+"))
{
Switch ek = new Switch(eid);
emap.put(eid,ek);
}
else if(eid.matches("F\d+"))
{
Equipment ef = new Devide(eid);
emap.put(eid,ef);
}
else if(eid.matches("L\d+"))
{
Equipment el = new Continue(eid);
emap.put(eid,el);
}
else if(eid.matches("B\d+"))
{
Equipment eb = new Bright(eid);
emap.put(eid,eb);
}
else if(eid.matches("R\d+"))
{
Equipment er = new Sun(eid);
emap.put(eid,er);
}
else if(eid.matches("D\d+"))
{
Equipment ed = new Fan(eid);
emap.put(eid,ed);
}
else if(eid.matches("A\d+"))
{
Equipment ea = new AFan(eid);
emap.put(eid,ea);
}
else if(eid.matches("H\d+-\d+"))
{
Equipment eh = new Hswitch(eid);
emap.put(eid,eh);
}
else if(eid.matches("S\d+"))
{
Equipment es = new S(eid);
emap.put(eid,es);
}
}
for(String cin:controllist)
{
if(cin.startsWith("#K"))
{
String k=cin.substring(1);
if(emap.containsKey(k))
{
((Switch)emap.get(k)).changestate();
}
}
else if(cin.startsWith("#F"))
{
String f=cin.substring(1);
int index1 = f.indexOf("F");
int index2 = f.indexOf("+");
int index3 = f.indexOf("-");
if(index2>0)
{
String f1 = f.substring(index1,index2);
if(emap.containsKey(f1))
{
((Devide)emap.get(f1)).speedlevel++;
}
}
else if(index3>0)
{
String f2 = f.substring(index1,index3);
if(emap.containsKey(f2))
{
((Devide)emap.get(f2)).speedlevel--;
}
}
}
else if(cin.startsWith("#L"))
{
String l=cin.substring(1);
String l1[] = l.split("😊;
if(emap.containsKey(l1[0]))
{
((Continue)emap.get(l1[0])).setparameter(Double.parseDouble(l1[1]));
}
}
else if(cin.startsWith("#H"))
{
String h = cin.substring(1);
for(String key:emap.keySet())
{
Pattern pat = Pattern.compile("(H\d+)-(\d+)");
Matcher mat = pat.matcher(key);
if(mat.find()) {
String a = mat.group(1);
if (a.equals(h)) {
((Hswitch) emap.get(key)).change();
}
}
}
}
}
for(String eid:neweidlist)
{
//
if(eid.matches("T\d+"))
{
for(String id:((Series)(emap.get(eid))).selist)
{
if(emap.containsKey(id))
{
((Series)emap.get(eid)).semap.put(id,emap.get(id));
}
}
}
if(eid.matches("M\d+"))
{
for(String id:((Parallel)emap.get(eid)).pelist)
{
if(emap.containsKey(id))
{
((Parallel)emap.get(eid)).pemap.put(id,emap.get(id));
}
}
}
}

    for(int i=0;i<chuanlist.size();i++)
    {
        chuanlist.get(i).changestate();
    }

    for(String eid:neweidlist)
    {

//System.out.println(eid);
if(eid.matches("T\d+"))
{
for(String id:((Series)(emap.get(eid))).selist)
{
if(emap.containsKey(id)&&!emap.get(id).type.equals("H"))
{
emap.get(eid).resistance+=emap.get(id).resistance;
//System.out.println(id+emap.get(id).resistance);
}
else
{
((Hswitch)emap.get(id)).changer();
//System.out.println(id+emap.get(id).resistance);
emap.get(eid).resistance+=emap.get(id).resistance/2;
}
}
}
if(eid.matches("M\d+"))
{
((Parallel)emap.get(eid)).changer();
}
}

    //輸出
    LinkedList<Equipment> elist = new LinkedList(emap.values());
    //裝置inv變動
    //System.out.println(elist.size());
    double inv=220.01;
    Equipment e =chuanlist.get(chuanlist.size()-1);
    for(String id:((Series)e).semap.keySet())
    {

//System.out.println(id);
Equipment newe = ((Series)e).semap.get(id);

        if(newe.type.equals("K"))
        {
            inv=((Switch)newe).changeoutv(inv);
        }
        else if(newe.type.equals("F"))
            inv=((Devide)newe).changeoutv(inv);
        else if(newe.type.equals("L"))
            inv=((Continue)newe).changeoutv(inv);
    }
    //System.out.println(inv);
    if(((Series)e).state!=1)
    {
        for(String id:((Series)e).semap.keySet())
        {
            //System.out.println(id);
            Equipment newe = ((Series)e).semap.get(id);
            //System.out.println(newe.type);
            double r;
            if(newe.type.equals("B"))
            {
                r=10;
                ((Bright)newe).setlight(inv*r/((Series)e).resistance);
            }
            else if(newe.type.equals("R"))
            {
                r=5;
                ((Sun)newe).setlight(inv*r/((Series)e).resistance);
            }
            else if(newe.type.equals("D"))
            {
                r=20;
                ((Fan)newe).setrotate(inv*r/ e.resistance);
                //System.out.println(((Fan)newe).rotate);
            }
            else if(newe.type.equals("A"))
            {r=20;
                ((AFan)newe).setrotate(inv*r/ e.resistance);}

            else if(newe.type.equals("P"))
            {
                newe.inv=inv* ((Series)e).semap.get(id).resistance/ e.resistance;
                for(String s:((Parallel)newe).pemap.keySet())
                {
                    Equipment e2 =((Parallel)newe).pemap.get(s);
                    //System.out.println(((Series)e2).state);
                    if(((Series)e2).state==0)
                    {
                        for(String key:((Series)e2).semap.keySet())
                        {
                            Equipment newe11=((Series)e2).semap.get(key);
                            double r1;
                            //System.out.println(newe1.type);
                            if(newe11.type.equals("B"))
                            {
                                r1=10;
                                ((Bright)newe11).setlight(inv*r1/ e2.resistance);
                            }
                            else if(newe11.type.equals("R"))
                            {
                                r1=5;
                                ((Sun)newe11).setlight(inv*r1/ e2.resistance);
                            }

                            else if(newe11.type.equals("D"))
                            {r1=20;
                                ((Fan)newe11).setrotate(inv*r1/ e2.resistance);
                            }
                            else if(newe11.type.equals("A"))
                            {
                                r1=20;
                                ((AFan)newe11).setrotate(inv*r1/ e2.resistance);
                            }
                            else if(newe11.type.equals("S"))
                            {
                                r1= newe11.resistance;
                                newe11.inv = inv*r1/ e2.resistance;
                            }
                            else if(newe11.type.equals("P"))
                            {
                                newe11.inv=inv* ((Series)e2).semap.get(key).resistance/ e2.resistance;
                            }
                            else if(newe11.type.equals("S1"))
                            {
                                r1=15;
                                newe11.inv = inv*r1/ e2.resistance;
                            }
                            else if (newe11.type.equals("H"))
                            {
                                newe11.inv=inv* ((Series)e2).semap.get(key).resistance/ e2.resistance;
                            }
                        }
                    }
                    else
                    {
                        for(String key:((Series)e2).semap.keySet())
                        {
                            //System.out.println(id);
                            Equipment newe2 = ((Series)e2).semap.get(key);
                            //System.out.println(newe.type);
                            double r1;
                            if(newe2.type.equals("B"))
                            {
                                r1=10;
                                ((Bright)newe2).setlight(0);
                            }
                            else if(newe2.type.equals("R"))
                            {
                                r1=5;
                                ((Sun)newe2).setlight(0);
                            }
                            else if(newe2.type.equals("D"))
                            {r1=20;
                                ((Fan)newe2).setrotate(0);}
                            else if(newe2.type.equals("A"))
                            {r1=20;
                                ((AFan)newe2).setrotate(0);}
                            else if(newe2.type.equals("S1"))
                            {
                                r1=15;
                                ((S)newe2).inv=0;
                            }
                        }
                    }
                }
            }
            else if(newe.type.equals("S1"))
            {
                r=15;
                newe.inv=inv* r/ e.resistance;
            }
            else if(newe.type.equals("S"))
            {
                if(((Series)newe).state==0) {
                    newe.inv = inv * ((Series) e).semap.get(id).resistance / e.resistance;
                }
                else {
                    newe.inv = 0;
                }
            }
        }
        for(int j=0;j<chuanlist.size()-1;j++)
        {
            Series series = chuanlist.get(j);
            inv = series.inv;
            if(series.state!=1) {
                for (String id : series.semap.keySet()) {
                    //System.out.println(id);
                    Equipment newe1 = series.semap.get(id);
                    //System.out.println(newe.type);
                    double r;
                    if (newe1.type.equals("B")) {
                        r = 10;
                        ((Bright) newe1).setlight(inv * r / series.resistance);
                    } else if (newe1.type.equals("R")) {
                        r = 5;
                        ((Sun) newe1).setlight(inv * r / series.resistance);
                    } else if (newe1.type.equals("D")) {
                        r = 20;
                        ((Fan) newe1).setrotate(inv * r / series.resistance);
                        //System.out.println(((Fan)newe).rotate);
                    } else if (newe1.type.equals("A")) {
                        r = 20;
                        ((AFan) newe1).setrotate(inv * r / series.resistance);
                    } else if (newe1.type.equals("P")) {
                        newe1.inv = inv * series.semap.get(id).resistance / series.resistance;
                    }
                    else if(newe1.type.equals("S"))
                    {
                        newe1.inv = inv*series.semap.get(id).resistance/series.resistance;
                    }
                    else if (newe1.type.equals("S1")) {
                        r = 15;
                        newe1.inv = inv * r / series.resistance;
                    }
                }
            }
        }
        for(int i = 0;i<binglist.size();i++)
        {
            inv = binglist.get(i).inv;

//System.out.println(inv);
for(String s:binglist.get(i).pemap.keySet())
{
Equipment e2 =binglist.get(i).pemap.get(s);
if(((Series)e2).state==0)
{
for(String id:((Series)e2).semap.keySet())
{
Equipment newe1=((Series)e2).semap.get(id);
double r1;
//System.out.println(newe1.type);
if(newe1.type.equals("B"))
{
r1=10;
((Bright)newe1).setlight(invr1/ e2.resistance);
}
else if(newe1.type.equals("R"))
{
r1=5;
((Sun)newe1).setlight(invr1/ e2.resistance);
}

                        else if(newe1.type.equals("D"))
                        {r1=20;
                            ((Fan)newe1).setrotate(inv*r1/ e2.resistance);
                        }
                        else if(newe1.type.equals("A"))
                        {
                            r1=20;
                            ((AFan)newe1).setrotate(inv*r1/ e2.resistance);
                        }
                        else if(newe1.type.equals("S"))
                        {
                            r1= newe1.resistance;
                            newe1.inv = inv*r1/ e2.resistance;
                        }
                        else if(newe1.type.equals("P"))
                        {
                            newe1.inv=inv* ((Series)e2).semap.get(id).resistance/ e2.resistance;
                        }
                        else if(newe1.type.equals("S1"))
                        {
                            r1=15;
                            newe1.inv = inv*r1/ e2.resistance;
                        }
                        else if (newe1.type.equals("H"))
                        {
                            newe1.inv=inv* ((Series)e2).semap.get(id).resistance/ e2.resistance;
                        }
                    }
                }
                else
                {
                    for(String id:((Series)e2).semap.keySet())
                    {
                        //System.out.println(id);
                        Equipment newe = ((Series)e2).semap.get(id);
                        //System.out.println(newe.type);
                        double r;
                        if(newe.type.equals("B"))
                        {
                            r=10;
                            ((Bright)newe).setlight(0);
                        }
                        else if(newe.type.equals("R"))
                        {
                            r=5;
                            ((Sun)newe).setlight(0);
                        }
                        else if(newe.type.equals("D"))
                        {r=20;
                            ((Fan)newe).setrotate(0);}
                        else if(newe.type.equals("A"))
                        {r=20;
                            ((AFan)newe).setrotate(0);}
                        // else if(newe.type.equals("P"))
                        // {
                        //     ((Parallel)newe).inv=0;
                        // }
                    }
                }
            }
        }
    }
    else
    {
        for(String id:((Series)e).semap.keySet())
        {
            //System.out.println(id);
            Equipment newe = ((Series)e).semap.get(id);
            //System.out.println(newe.type);
            double r;
            if(newe.type.equals("B"))
            {
                r=10;
                ((Bright)newe).setlight(0);
            }
            else if(newe.type.equals("R"))
            {
                r=5;
                ((Sun)newe).setlight(0);
            }
            else if(newe.type.equals("D"))
            {
                r=20;
                ((Fan)newe).setrotate(0);
                //System.out.println(((Fan)newe).rotate);
            }
            else if(newe.type.equals("A"))
            {r=20;
                ((AFan)newe).setrotate(0);}

            else if(newe.type.equals("P"))
            {
                newe.inv=0;
                for(String s:((Parallel)newe).pemap.keySet())
                {
                    Equipment e2 =((Parallel)newe).pemap.get(s);
                    //System.out.println(((Series)e2).state);
                    if(((Series)e2).state==0)
                    {
                        for(String key:((Series)e2).semap.keySet())
                        {
                            Equipment newe11=((Series)e2).semap.get(key);
                            double r1;
                            //System.out.println(newe1.type);
                            if(newe11.type.equals("B"))
                            {
                                r1=10;
                                ((Bright)newe11).setlight(0);
                            }
                            else if(newe11.type.equals("R"))
                            {
                                r1=5;
                                ((Sun)newe11).setlight(0);
                            }

                            else if(newe11.type.equals("D"))
                            {r1=20;
                                ((Fan)newe11).setrotate(0);
                            }
                            else if(newe11.type.equals("A"))
                            {
                                r1=20;
                                ((AFan)newe11).setrotate(0);
                            }
                            else if(newe11.type.equals("S"))
                            {
                                r1= newe11.resistance;
                                newe11.inv = 0;
                            }
                            else if(newe11.type.equals("P"))
                            {
                                newe11.inv=0;
                            }
                            else if(newe11.type.equals("S1"))
                            {
                                r1=15;
                                newe11.inv = 0;
                            }
                            else if (newe11.type.equals("H"))
                            {
                                newe11.inv=0;
                            }
                        }
                    }
                    else
                    {
                        for(String key:((Series)e2).semap.keySet())
                        {
                            //System.out.println(id);
                            Equipment newe2 = ((Series)e2).semap.get(key);
                            //System.out.println(newe.type);
                            double r1;
                            if(newe2.type.equals("B"))
                            {
                                r1=10;
                                ((Bright)newe2).setlight(0);
                            }
                            else if(newe2.type.equals("R"))
                            {
                                r1=5;
                                ((Sun)newe2).setlight(0);
                            }
                            else if(newe2.type.equals("D"))
                            {r1=20;
                                ((Fan)newe2).setrotate(0);}
                            else if(newe2.type.equals("A"))
                            {r1=20;
                                ((AFan)newe2).setrotate(0);}
                            else if(newe2.type.equals("S1"))
                            {
                                r1=15;
                                ((S)newe2).inv=0;
                            }
                        }
                    }
                }
            }
            else if(newe.type.equals("S1"))
            {
                r=15;
                newe.inv=0;
            }
            else if(newe.type.equals("S"))
            {
                if(((Series)newe).state==0) {
                    newe.inv = 0;
                }
                else {
                    newe.inv = 0;
                }
            }
        }
        for(int j=0;j<chuanlist.size()-1;j++)
        {
            Series series = chuanlist.get(j);
            inv = series.inv;
            if(series.state!=1) {
                for (String id : series.semap.keySet()) {
                    //System.out.println(id);
                    Equipment newe1 = series.semap.get(id);
                    //System.out.println(newe.type);
                    double r;
                    if (newe1.type.equals("B")) {
                        r = 10;
                        ((Bright) newe1).setlight(0);
                    } else if (newe1.type.equals("R")) {
                        r = 5;
                        ((Sun) newe1).setlight(0);
                    } else if (newe1.type.equals("D")) {
                        r = 20;
                        ((Fan) newe1).setrotate(0);
                        //System.out.println(((Fan)newe).rotate);
                    } else if (newe1.type.equals("A")) {
                        r = 20;
                        ((AFan) newe1).setrotate(0);
                    } else if (newe1.type.equals("P")) {
                        newe1.inv = 0;
                    }
                    else if(newe1.type.equals("S"))
                    {
                        newe1.inv = 0;
                    }
                    else if (newe1.type.equals("S1")) {
                        r = 15;
                        newe1.inv = 0;
                    }
                }
            }
        }
        for(int i = 0;i<binglist.size();i++)
        {
            inv = binglist.get(i).inv;

//System.out.println(inv);
for(String s:binglist.get(i).pemap.keySet())
{
Equipment e2 =binglist.get(i).pemap.get(s);
if(((Series)e2).state==0)
{
for(String id:((Series)e2).semap.keySet())
{
Equipment newe1=((Series)e2).semap.get(id);
double r1;
//System.out.println(newe1.type);
if(newe1.type.equals("B"))
{
r1=10;
((Bright)newe1).setlight(0);
}
else if(newe1.type.equals("R"))
{
r1=5;
((Sun)newe1).setlight(0);
}

                        else if(newe1.type.equals("D"))
                        {r1=20;
                            ((Fan)newe1).setrotate(0);
                        }
                        else if(newe1.type.equals("A"))
                        {
                            r1=20;
                            ((AFan)newe1).setrotate(0);
                        }
                        else if(newe1.type.equals("S"))
                        {
                            r1= newe1.resistance;
                            newe1.inv = 0;
                        }
                        else if(newe1.type.equals("P"))
                        {
                            newe1.inv=0;
                        }
                        else if(newe1.type.equals("S1"))
                        {
                            r1=15;
                            newe1.inv = 0;
                        }
                        else if (newe1.type.equals("H"))
                        {
                            newe1.inv=0;
                        }
                    }
                }
                else
                {
                    for(String id:((Series)e2).semap.keySet())
                    {
                        //System.out.println(id);
                        Equipment newe = ((Series)e2).semap.get(id);
                        //System.out.println(newe.type);
                        double r;
                        if(newe.type.equals("B"))
                        {
                            r=10;
                            ((Bright)newe).setlight(0);
                        }
                        else if(newe.type.equals("R"))
                        {
                            r=5;
                            ((Sun)newe).setlight(0);
                        }
                        else if(newe.type.equals("D"))
                        {r=20;
                            ((Fan)newe).setrotate(0);}
                        else if(newe.type.equals("A"))
                        {r=20;
                            ((AFan)newe).setrotate(0);}
                        // else if(newe.type.equals("P"))
                        // {
                        //     ((Parallel)newe).inv=0;
                        // }
                    }
                }
            }
        }
    }
    double light=0;
    for(int i=0;i<chuanlist.size();i++)
    {
        Series series = chuanlist.get(i);
        for(String str:series.semap.keySet())
        {
            if(str.startsWith("B"))
            {
                light+=((Bright)series.semap.get(str)).light;
            }
            else if(str.startsWith("R"))
            {
                light+=((Sun)series.semap.get(str)).light;
            }
        }
    }
    for(int i=0;i<chuanlist.size();i++)
    {
        Series series = chuanlist.get(i);
        for(String str:series.semap.keySet())
        {
            if(str.startsWith("S"))
            {
                ((S)series.semap.get(str)).changeopenness(light);
            }
        }
    }
    Collections.sort(elist,new comparator());
    ArrayList<String> a = new ArrayList<>();
    for(Equipment e1:elist)
    {
        if(!e1.type.equals("H"))
            e1.display(e1);
        else
        {
            Pattern pat = Pattern.compile("(\\w+)-(\\w+)");
            Matcher mat = pat.matcher(e1.id);
            mat.find();
            String nid = mat.group(1);
            if(!a.contains(nid)) {
                a.add(nid);
                System.out.println("@"+nid+":"+((Hswitch)e1).state);
            }
        }
    }
}

}
class Equipment{
String type;
String id;
double resistance=0;
double inv;
double outv;
public Equipment(){}
public Equipment(String type,String id){
this.type=type;
this.id=id;
}
public void display(Equipment e){
if(type.equals("K"))
{
if(((Switch)e).state0)
System.out.println( "@"+id+":turned on");
else if(((Switch)e).state1)
System.out.println ("@"+id+":closed");
}
else if(type.equals("F"))
{
System.out.println ("@"+id+":"+ ((Devide)e).speedlevel);
}
else if(type.equals("L"))
{
System.out.println ("@"+id+":"+String.format("%.2f",((Continue)e).parameter));
}
else if(type.equals("B"))
{
System.out.println ("@"+id+":"+(int)Math.floor(((Bright)e).light));
}
else if(type.equals("R"))
{
System.out.println ("@"+id+":"+(int)Math.floor(((Sun)e).light));
}
else if(type.equals("D"))
{
System.out.println ("@"+id+":"+(int)Math.floor(((Fan)e).rotate));
}
else if(type.equals("A"))
{
System.out.println ("@"+id+":"+(int)Math.floor(((AFan)e).rotate));
}
else if(type.equals("S1"))
{
System.out.println ("@"+id+":"+((S)e).openness);
}
}
}
class Switch extends Equipment{
int state;
public Switch(){

}
public Switch(String id){
    super("K",id);
    this.state=0;
    this.resistance=0;
}
public void changestate(){
    if(state==0)
        state=1;
    else
        state=0;
}
public double changeoutv(double inv){
    if(state==0)
        outv=0;
    else if(state==1)
    {
        outv=inv;
    }
    return outv;
}

}
class Devide extends Equipment{
int speedlevel;
public Devide(){}
public Devide(String id){
super("F",id);
this.speedlevel=0;
this.resistance=0;
}
public double changeoutv(double inv){
if(speedlevel>=0)
{
switch(speedlevel)
{
case 0:outv=inv0;break;
case 1:outv=inv0.3;break;
case 2:outv=inv0.6;break;
case 3:outv=inv0.9;break;
default:outv=inv0.9;speedlevel=3;break;
}
}
else
speedlevel=0;
return outv;
}
}
class Continue extends Equipment{
double parameter;
public Continue(){}
public Continue(String id){
super("L",id);
this.parameter=0;
this.resistance=0;
}
public void setparameter(double p){
this.parameter=p;
}
public double changeoutv(double inv)
{
if(parameter<0||parameter>1)
return 0;
else{
if(inv==0)
outv=0;
else
{
outv=invparameter;
}
}
return outv;
}
}
class Bright extends Equipment{
double light;
public Bright(){}
public Bright(String id){
super("B",id);
this.light=0;
this.resistance=10;
}
public void setlight(double inv){
//System.out.println(inv);
if(inv>=0&&inv<=9)
light=0;
else if(inv>9&&inv<220)
{
light=5(inv-10)/7+50;
}
else
light=200;
}
}
class Sun extends Equipment{
double light;
public Sun(){}
public Sun(String id){
super("R",id);
this.light=0;
this.resistance=5;
}
public void setlight(double inv){
if(inv==0)
this.light=0;
else
this.light=180;
}
}
class Fan extends Equipment{
double rotate;
public Fan(){}
public Fan(String id){
super("D",id);
this.rotate=0;
this.resistance=20;
}
public void setrotate(double inv){
//System.out.println(inv);
if(inv<80)
this.rotate=0;
else
{
if(inv>=80&&inv<=150)
this.rotate=4.00000000000001(inv-80)+80;
else if(inv>150)
this.rotate=360;
}
//System.out.println(rotate);
}
}
class AFan extends Equipment{
double rotate;
public AFan(){}
public AFan(String id){
super("A",id);
this.rotate=0;
this.resistance=20;
}
public void setrotate(double inv){
//System.out.println(id+inv);
if(inv<80)
this.rotate=0;
else
{
if(inv>=80&&inv<=99)
this.rotate=80;
else if(inv>99&&inv<120)
this.rotate=160;
else if(inv>=120&&inv<140)
this.rotate=260;
else if(inv>=140)
this.rotate=360;
}
}
}
class Hswitch extends Equipment{
String state;
boolean ison2 ;
boolean ison3 ;
public Hswitch(String id){
super("H",id);
ison2 = false ;
ison3 = true ;
}
public void change()
{
ison2 = !ison2;
ison3 = !ison3 ;
}
public void changer()
{
this.resistance = (ison2?10:5);
state = (ison2?"turned on":"closed");
}
}
class S extends Equipment{
String openness;
public S(String id){
super("S1",id);
this.resistance=15;
}
public void changeopenness(double light)
{
if(inv<50)
{
openness = "100%";
}
else if(inv>=50)
{
if(0<=light&&light<50)
{
openness="100%";
}
if(light>=50&&light<100)
{
openness = "80%";
}
else if(light>=100&&light<200)
{
openness = "60%";
}
else if(light>=200&&light<300)
{
openness = "40%";
}
else if(light>=300&&light<400)
{
openness = "20%";
}
else
openness = "0%";
}
}
}
//series-parallel
//串聯
class Series extends Equipment{
int state;
LinkedList selist = new LinkedList<>();
LinkedHashMap <String,Equipment> semap = new LinkedHashMap<>();
public Series(String id){
super("S",id);
this.state=0;
}
public void changestate() {
for (String id : semap.keySet()) {
if (id.matches("K\d+")) {
//System.out.println(((Switch)semap.get(id)).state);
if (((Switch) semap.get(id)).state == 0)
this.state = 1;
}
}
for(String key:semap.keySet())
{
if(key.startsWith("H"))
{
if(semap.get(key).id.matches("H\d+-3")&&((Hswitch)semap.get(key)).ison3)
this.state=1;
else if(semap.get(key).id.matches("H\d+-2")&&((Hswitch)semap.get(key)).ison2)
this.state=1;
}
}
for(String key : semap.keySet())
{
if(key.startsWith("T"))
{
if(((Series)semap.get(key)).state1)
this.state=1;
}
}
for(String key : semap.keySet())
{
if(key.startsWith("T"))
{
if(state1)
{
((Series)semap.get(key)).state=1;
}
}
}
}
}

//並聯
class Parallel extends Equipment{
LinkedListpelist = new LinkedList<>();
LinkedHashMap<String,Equipment> pemap = new LinkedHashMap<>();
public Parallel(String id){
super("P",id);
this.resistance=0;
}
public void changer()
{
for(String s:pemap.keySet())
{
//System.out.println(((Series)pemap.get(s)).state);
if(((Series)pemap.get(s)).state==0)
{
this.resistance+=1/pemap.get(s).resistance;
//System.out.println(pemap.get(s).resistance);
}
}
this.resistance=1/this.resistance;
//System.out.println(this.resistance);
}
}

class comparator implements Comparator{
private static final List order = Arrays.asList('K', 'F', 'L', 'B', 'R', 'D','A','H','S');
@Override
public int compare(Equipment o1, Equipment o2) {
String key1 = o1.id;
String key2 = o2.id;
int order1 = order.indexOf(key1.charAt(0));
int order2 = order.indexOf(key2.charAt(0));
if (order1 != order2) {
return order1 - order2;
}
else
{
return key1.compareTo(key2);
}
}
}
第八次pta作業題目：
智慧家居是在當下家庭中越來越流行的一種配置方案，它透過物聯網技術將家中的各種裝置（如音影片裝置、照明系統、窗簾控制、空調控制、安防系統、數字影院系統、影音伺服器、影櫃系統、網路家電等）連線到一起，提供家電控制、照明控制、電話遠端控制、室內外遙控、防盜報警、環境監測、暖通控制、紅外轉發以及可程式設計定時控制等多種功能和手段。與普通家居相比，智慧家居不僅具有傳統的居住功能，兼備建築、網路通訊、資訊家電、裝置自動化，提供全方位的資訊互動功能。請根據如下要去設計一個智慧家居強電電路模擬系統。以下題目介紹中加粗的部分為本次迭代在“家居強電電路模擬程式-3”的基礎上增加的功能要求。
1、控制裝置
本題模擬的控制裝置包括：開關、分檔調速器、連續調速器、互斥開關。
開關：包括0和1兩種狀態。
開關有兩個引腳，任意一個引腳都可以是輸入引腳（接往電源端），而另一個則是輸出引腳（接網接地端）。開關狀態為0時，無論輸入電位是多少，輸出引腳電位為0。當開關狀態為1時，輸出引腳電位等於輸入電位。
互斥開關：
互斥開關有3個引腳：1個是彙總引腳，另兩個是分支引腳。

解釋
開關電路示意圖如圖1所示，左邊是彙總引腳，編號為1；右邊兩個是分支引腳，右上的輸出引腳為2，右下輸出引腳為3。圖中1、2、3引腳均可以是輸入引腳，當1為輸入引腳時，2、3引腳為輸出引腳；1為輸出引腳時，2、3引腳為輸入引腳。
互斥開關只有兩種狀態：開關接往上面的2號引腳、接往下面的3號引腳。開關每次只能接通其中一個分支引腳，而另一個分支引腳處於斷開狀態。
互斥開關的預設狀態為1、2引腳接通，1、3引腳斷開。
圖1中所示的互斥開關可以反過來接入電路，即彙總引腳接往接地端，兩個分支引腳接往電源端。

圖1 互斥開關
為避免短路，互斥開關設定了限流電阻，1、2引腳之間預設電阻為5，1、3引腳之間預設電阻為10。

分檔調速器
按檔位調整，常見的有3檔、4檔、5檔調速器，檔位值從0檔-2（3/4）檔變化。本次迭代模擬4檔調速器，每個檔位的輸出電位分別為0、0.3、0.6、0.9倍的輸入電壓。
連續調速器
沒有固定檔位，按位置比例得到檔位引數，數值範圍在[0.00-1.00]之間，含兩位小數。輸出電位為檔位引數乘以輸入電壓。
所有調速器都有兩個引腳，一個固定的輸入（引腳編號為1）、一個輸出引腳（引腳編號為2）。當輸入電位為0時，輸出引腳輸出的電位固定為0，不受各類開關調節的影響。
開關、調速器的初始狀態/檔位為0。
開關的兩個引腳編號為1、2。
除互斥開關外，其他控制裝置的電阻為 0。
2、受控裝置
本題模擬的受控裝置包括：燈、風扇。兩種裝置都有兩根引腳，透過兩根引腳電壓的電壓差驅動裝置工作。
燈有兩種工作狀態：亮、滅。在亮的狀態下，有的燈會因引腳電位差的不同亮度會有區別。
風扇在接電後有兩種工作狀態：停止、轉動。風扇的轉速會因引腳間電位差的不同而有區別。
本次迭代模擬兩種燈具。
白熾燈：
亮度在0~200lux（流明）之間。
電位差為0-9V時亮度為0,其他電位差按比例，電位差10V對應50ux，220V對應200lux，其他電位差與對應亮度值成正比。白熾燈超過220V。
日光燈：
亮度為180lux。
只有兩種狀態，電位差為0時，亮度為0，電位差不為0，亮度為180。
本次迭代模擬兩種風扇。
吊扇：
工作電壓區間為80V-150V，對應轉速區間為80-360轉/分鐘。80V對應轉速為80轉/分鐘，150V對應轉速為360轉/分鐘，超過150V轉速為360轉/分鐘（本次迭代暫不考慮電壓超標的異常情況）。其他電壓值與轉速成正比，輸入輸出電位差小於80V時轉速為0。
落地扇：
工作電壓區間為 80V-150V，對應轉速區間為 80-360 轉/分鐘；[80V,100V) 對應轉速為 80 轉/分鐘；[100,120)V 對應轉速為 160 轉/分鐘；[120,140)V 對應轉速為 260 轉/分鐘；大於等於 140V 轉速為 360 轉/分鐘（本次迭代暫不考慮電壓超標的異常情況）。

本次迭代模擬一種受控窗簾：
解釋
受控串聯的電路符號為S，其最低工作電壓為50V，電壓達到或超過50V，窗簾即可正常工作，不考慮室外光照強度和室內空間大小等因素，窗簾受室內燈光的光照強度控制。
當電路中所有燈光的光照強度總和在[0,50)lux範圍內，窗簾全開；
在[50,100)lux範圍內，窗簾開啟比例為0.8；
在[100,200)lux範圍內，窗簾開啟比例為0.6；
在[200,300)lux範圍內，窗簾開啟比例為0.4；
在[300,400)lux範圍內，窗簾開啟比例為0.2；
在400lux及以上範圍內，窗簾關閉。
當電壓低於50V，窗簾不工作，預設為全開狀態。
如果電路中沒有燈或者燈全部關閉，光照強度為0，窗簾處於全開狀態。
受控裝置電阻：白熾燈的電阻為 10，日光燈的電阻為 5，吊扇的電阻為 20，落地扇的電阻為 20，窗簾電阻為15。

3、輸入資訊
1）輸入裝置資訊
分別用裝置識別符號K、F、L、B、R、D、A、H、S、P分別表示開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、落地扇、互斥開關、受控窗簾、二極體（見第6部分說明）。
裝置標識用識別符號+編號表示，如K1、F3、L2等。
解釋
引腳格式：
裝置標識-引腳編號，例如：K1-1標識編號為1的開關的1號引腳。
開關、分檔調速器、連續調速器的兩個引腳編號為1、2。
受控裝置的兩個引腳編號分別為1、2。
互斥開關的引腳編號已經在互斥開關的介紹部分說明。

約束條件：
不同裝置的編號可以相同。
裝置資訊不單獨輸入，包含在連線資訊中。

2）輸入連線資訊
一條連線資訊佔一行，用[]表示一組連線在一起的裝置引腳，引腳與引腳之間用英文空格" "分隔。
解釋
格式：
"["+引腳號+" "+引腳號+"]"
例如：[K1-1 K3-2]表示K1的1號引腳，K3的2號引腳連線在一起。

約束條件：
不考慮調速器串聯到其他調速器的情況。
考慮各類裝置的並聯接入。例如，K1 的輸出接到 L2 的輸入，L2 的輸出再接其他裝置屬於串聯接線。K1 的輸出接到 L2 的輸出，同時 K1 的輸入接到 L2 的輸入，這種情況屬於並聯。
連線資訊不單獨輸入，包含線上路資訊中。

3）輸入控制裝置調節資訊
開關、互斥開關調節資訊格式：

+裝置標識K+裝置編號，例如：#K2，代表切換K2開關的狀態。

+裝置標識H+裝置編號，例如：#H2，代表切換H2互斥開關的狀態。

分檔調速器的調節資訊格式：

+裝置標識F+裝置編號+"+" 代表加一檔，例如：#F3+，代表F3輸出加一檔。

+裝置標識F+裝置編號+"-" 代表減一檔，例如：#F1-，代表F1輸出減一檔。

連續調速器的調節資訊格式：

+裝置標識L+裝置編號+":" +數值代表將連續調速器的檔位設定到對應數值，例如：#L3:0.6，代表L3輸出檔位引數0.6。

4）電源接地標識：
VCC，電壓220V，GND，電壓0V。沒有接線的引腳預設接地，電壓為0V。

5）輸入串聯電路資訊
一條串聯電路佔一行，串聯電路資訊由 n 個連線資訊組成，連線資訊按從靠電源端到接地端順序依次輸入，連線資訊之間用英文空格" "分隔。
解釋
串聯電路資訊格式：
"#T"+電路編號+":"+連線資訊+" "+連線資訊+...+" "+連線資訊
例如：#T1:[IN K1-1] [K1-2 D2-1] [D2-2 OUT] 一個串聯電路的第一個引腳是 IN，代表起始端，靠電源。最後一個引腳是 OUT，代表結尾端，靠接地。

約束條件：
不同的串聯電路資訊編號不同。
輸入的最後一條電路資訊必定是總電路資訊，總電路資訊的起始引腳是 VCC，結束引腳是 GND。
連線資訊中的引腳可能是一條串聯或並聯電路的 IN 或者 OUT。例如：

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT OUT]

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT M2-IN] [M2-OUT OUT]

6）輸入並聯電路資訊
一條並聯電路佔一行，並聯電路由其包含的幾條串聯電路組成，串聯電路標識之間用英文空格" "分隔。
格式：
"#M"+電路編號+":"+”[”+串聯電路資訊+" "+....+" "+串聯電路資訊+”]”
例如：#M1:[T1 T2 T3]
該例宣告瞭一個並聯電路，由 T1、T2、T3 三條串聯電路並聯而成，三條串聯電路的 IN 短接在一起構成 M1 的 IN，三條串聯電路的 OUT 短接在一起構成 M1 的 OUT。
在本題中，並聯電路M中的串聯電路可以包含別的並聯電路。
約束條件：
解釋
本題不考慮輸入電壓或電壓差超過220V的情況。
輸入資訊以end為結束標誌，忽略end之後的輸入資訊。
本題中的並聯資訊所包含的串聯電路的資訊都在並聯資訊之前輸入，不考慮亂序輸入的情況。
只要不因短路而造成無窮大的電流燒壞電路(如電路中的部分短接)，都是合理情況。
本次迭代考慮多個並聯電路串聯在一起的情況。
本題考慮一條串聯電路中包含其他串聯電路和並聯電路的情況。例如：

T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]

本例中T1\T2兩條串聯電路是T3的一個部分，本題考慮這種型別的輸入。
4、輸出資訊：
按開關、分檔調速器、連續調速器、白熾燈、日光燈、吊扇、互斥開關、受控窗簾、二極體（見第6部分說明）的順序依次輸出所有裝置的狀態或引數。每個裝置一行。同類裝置按編號順序從小到大輸出。
輸出格式：
@裝置標識+裝置編號+":" +裝置引數值（控制開關的檔位或狀態、燈的亮度、風扇的轉速，只輸出值，不輸出單位）+" "+裝置所有引腳的電壓（按編號從小到大順序依次輸出，電壓的小數部分直接丟棄，保留整數輸出，電壓之間用”-”分隔）
解釋
說明：
連續調速器的檔位資訊保留兩位小數，即使小數為0，依然顯示兩位小數.00。
開關狀態為0（開啟）時顯示turned on，狀態為1（合上）時顯示closed
如：
@K1:turned on 32-15
@B1:190 68-17
@L1:0.60 220-176
互斥開關按1、2引腳的接通狀態顯示，1，2接通-1，3斷開時顯示closed，1，3接通-1，2斷開時顯示turned on。
如：
@H1:turned on
受控窗簾顯示窗簾開啟的百分比，如：
@S1:80%

5、家居電路模擬系列所有題目的預設規則
1）當計算電壓值等數值的過程中，最終結果出現小數時，用截尾規則去掉小數部分，只保留整數部分。為避免精度的誤差，所有有可能出現小數的數值用double型別儲存並計算，不要作下轉型資料型別轉換，例如電壓、轉速、亮度等，只有在最後輸出時再把計算結果按截尾規則，捨棄尾數，保留整數輸出。
2）所有連線資訊按電路從靠電源端到靠接地端的順序依次輸入，不會出現錯位的情況。VCC/IN一定是第一個連線的第一項，GND/OUT一定是最後一個連線的後一項。
3）連線資訊如果只包含兩個引腳，靠電源端的引腳在前，靠接地端的在後。
4）調速器的輸入端只會直連VCC，不會接其他裝置。整個電路最多隻有連線在電源上的一個調速器，且不包含在並聯單路中。
5）本系列題目中元件的管腳除了互斥開關的1引腳，其他所有引腳在電路中最多隻出現一次。
6、本題新增內容：
1）增加管腳電壓的顯示
在輸出每個電器的狀態資訊後，再依次輸出該電器每個管腳的電壓。（格式詳見輸出資訊部分）

2）電流限制
電器在工作時，過大的電流會引起電器過熱，從而燒壞電路。本次迭代，每個元器件都有最大電流的設定，當實時電流超過最大電流時，在該電器輸出資訊的最後加入提示“exceeding current limit error”，與前面的資訊之間用英文空格分隔。
例如：@B1:190 68-17 exceeding current limit error
本題各類電器的最大限定電流如下：
開關20、分檔調速器18、連續調速器18、白熾燈9、日光燈5、吊扇12、落地扇14、互斥開關20、受控窗簾12、二極體8。

3）短路檢測
如果電路出現無窮大的電流造成短路，所有元器件資訊不輸出，僅輸出提示“short circuit error”

4）並聯電路中包含並聯
本次迭代考慮並聯電路中包含並聯電路的情況，即構成並聯電路的串聯電路可以包含別的並聯電路。例如如下輸入的電路，並聯電路M2的其中一條串聯電路T4中包含了另一條並聯電路M1：
解釋

T1:[IN D2-1] [D2-2 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

5）二極體
增加二極體元件，其電路特性為：正向導通，反向截止；其電器符號如圖4所示，當電流從左至右流過時，二極體導通”conduction”，電阻為0；電流從右至左流動時，二極體截止”cutoff”，電阻無窮大，相當於開關開啟。

圖2 二極體符號
二極體的識別符號為’P’，左側管腳編號為1，右側管腳編號為2。
二極體如果兩端電壓相等，沒有電流流過，分以下兩種情況輸出：
1、如果兩端電壓為0，二極體的導通/截止狀態由接入方向決定，1號引腳靠近電源則狀態為導通，反之為截止。
2、如果兩端電壓不為0，二極體導通。

7、設計建議
本題包含以下電路圖中的所有連線情況：

圖3 電路示意圖
1、電路裝置類：描述所有電路裝置的公共特徵。
2、受控裝置類、控制裝置類：對應受控、控制裝置
3、串聯電路類：一條由多個電路裝置構成的串聯電路，也看成是一個獨立的電路裝置
4、並聯電路類：繼承電路裝置類，也看成是一個獨立的電路裝置
其他類以及類的屬性、方法自行設計。

圖4：建議設計類圖
輸入樣例1:
在這裡給出一組輸入。例如：
解釋

T1:[IN P2-2] [P2-1 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T3:[VCC K2-1] [K2-2 M2-IN] [M2-OUT GND]

K1

K2

end
輸出樣例1:
在這裡給出相應的輸出。例如：
解釋
@K1:closed 220-220 exceeding current limit error
@K2:closed 220-220 exceeding current limit error
@K3:turned on 220-0
@B1:200 220-0 exceeding current limit error
@D1:0 0-0
@H1:closed 0-0-0
@P2:cutoff 0-0
輸入樣例2:
在這裡給出一組輸入。例如：
解釋

T1:[IN P2-1] [P2-2 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T3:[VCC K2-1] [K2-2 M2-IN] [M2-OUT GND]

K1

K3

K2

end
輸出樣例2:
在這裡給出相應的輸出。例如：
解釋
@K1:closed 220-220 exceeding current limit error
@K2:closed 220-220 exceeding current limit error
@K3:closed 220-220 exceeding current limit error
@B1:200 220-0 exceeding current limit error
@D1:0 220-220
@H1:closed 0-220-220 exceeding current limit error
@P2:conduction 220-220 exceeding current limit error
輸入樣例3:
在這裡給出一組輸入。例如：
解釋

T1:[IN P2-2] [P2-1 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T3:[VCC K2-1] [K2-2 M2-IN] [M2-OUT GND]

K1

K3

K2

end
輸出樣例3:
在這裡給出相應的輸出。例如：
解釋
@K1:closed 220-220 exceeding current limit error
@K2:closed 220-220 exceeding current limit error
@K3:closed 220-220
@B1:200 220-0 exceeding current limit error
@D1:0 220-220
@H1:closed 0-0-220
@P2:cutoff 0-220
輸入樣例4:
在這裡給出一組輸入。例如：

T3:[VCC K2-1] [K2-2 GND]

K2

end
輸出樣例4:
在這裡給出相應的輸出。例如：
short circuit error
輸入樣例5:
在這裡給出一組輸入。如果兩端電壓為0，二極體的導通/截止狀態由接入方向決定，1號引腳靠近電源則狀態為導通，反之截止。例如：

T3:[VCC K2-2] [K2-1 P1-1] [P1-2 K1-2] [K1-1 GND]

end
輸出樣例5:
在這裡給出相應的輸出。例如：
@K1:turned on 0-0
@K2:turned on 0-220
@P1:conduction 0-0
輸入樣例6:
在這裡給出一組輸入。如果兩端電壓為0，二極體的導通/截止狀態由接入方向決定，1號引腳靠近電源則狀態為導通，反之截止。例如：

T3:[VCC K2-2] [K2-1 P1-2] [P1-1 K1-2] [K1-1 GND]

end
輸出樣例6:
####### 。例如：
@K1:turned on 0-0
@K2:turned on 0-220
@P1:cutoff 0-0
設計類圖：

程式碼如下：

import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Collections;
import java.util.*;

public class Main{
public static void main(String[] args) {
LinkedHashMap<String, Equipment> emap = new LinkedHashMap<>();
LinkedList controllist = new LinkedList<>();
LinkedList binglist = new LinkedList<>();
LinkedList chuanlist = new LinkedList<>();
Scanner in = new Scanner(System.in);
//輸入
while (true) {
String newin = in.nextLine();
if (newin.equals("end"))
break;
if (newin.startsWith("#T")) {
Pattern pat = Pattern.compile("#(T\d+)😦.)");
Matcher mat = pat.matcher(newin);
mat.find();
String sname = mat.group(1);
Equipment s = new Series(sname);
Pattern pat1 = Pattern.compile("(\w+)-(\w+)");
Matcher mat1 = pat1.matcher(newin);
while (mat1.find()) {
String id = mat1.group(1);
String pin = mat1.group(2);
Equipment e;
if(id.matches("K\d+"))
{
e = new Switch(id,pin);
}
else if(id.matches("F\d+"))
{
e = new Devide(id,pin);
}
else if(id.matches("L\d+"))
{
e = new Continue(id,pin);
}
else if(id.matches("B\d+"))
e = new Bright(id,pin);
else if(id.matches("R\d+"))
e = new Sun(id,pin);
else if(id.matches("D\d+"))
e = new Fan(id,pin);
else if(id.matches("A\d+"))
e = new AFan(id,pin);
else if(id.matches("S\d+"))
e = new S(id,pin);
else if(id.matches("P\d+"))
e = new P(id,pin);
else if(id.matches("H\d+"))
{
if(!emap.containsKey(id)) {
e = new Hswitch(id);
if (pin.equals("3")) {
((Hswitch) e).s3 = (Series) s;
e.isreserve=true;
} else if (pin.equals("2")) {
((Hswitch) e).s2 = (Series) s;
e.isreserve=true;
}
}
else
{
if (pin.equals("3")) {
((Hswitch) emap.get(id)).s3 = (Series) s;
} else if (pin.equals("2")) {
((Hswitch) emap.get(id)).s2 = (Series) s;
}
e = emap.get(id);
}
}
else if(id.matches("M\d+"))
{
if(emap.containsKey(id))
e=emap.get(id);
else
e=null;
}
else if(id.matches("T\d+"))
{
if(emap.containsKey(id))
e=emap.get(id);
else
e=null;
}
else
e=null;
if(!((Series) s).emap1.containsKey(id)&&e!=null)
{
((Series) s).emap1.put(id,e);
}
if(!emap.containsKey(id)&&e!=null)
emap.put(id,e);
}
emap.put(sname, s);
chuanlist.add((Series) s);
} else if (newin.startsWith("#M")) {
Pattern pat = Pattern.compile("#(M\d+)😦.)");
Matcher mat = pat.matcher(newin);
mat.find();
String pname = mat.group(1);
Equipment p = new Parallel(pname);
int index = newin.indexOf("😊;
String str1 = newin.substring(index + 1, newin.length() - 1);
String ps = str1.replaceAll("[\[\]]", "");
String[] pa = ps.split("\s+");
for (int i = 0; i < pa.length; i++) {
((Parallel) p).emap1.put(pa[i],emap.get(pa[i]));
}
emap.put(pname, p);
binglist.add((Parallel) p);
} else if (newin.startsWith("#K") || newin.startsWith("#L") || newin.startsWith("#F") || newin.startsWith("#H")) {
controllist.add(newin);
}
}
for (String cin : controllist) {
if (cin.startsWith("#K")) {
String k = cin.substring(1);
if (emap.containsKey(k)) {
((Switch) emap.get(k)).changestate();
}
} else if (cin.startsWith("#F")) {
String f = cin.substring(1);
int index1 = f.indexOf("F");
int index2 = f.indexOf("+");
int index3 = f.indexOf("-");
if (index2 > 0) {
String f1 = f.substring(index1, index2);
if (emap.containsKey(f1)) {
((Devide) emap.get(f1)).speedlevel++;
}
} else if (index3 > 0) {
String f2 = f.substring(index1, index3);
if (emap.containsKey(f2)) {
((Devide) emap.get(f2)).speedlevel--;
}
}
} else if (cin.startsWith("#L")) {
String l = cin.substring(1);
String l1[] = l.split("😊;
if (emap.containsKey(l1[0])) {
((Continue) emap.get(l1[0])).setparameter(Double.parseDouble(l1[1]));
}
} else if (cin.startsWith("#H")) {
String h = cin.substring(1);
((Hswitch) emap.get(h)).change();
}
}
for (int i = 0; i < chuanlist.size(); i++) {
if(chuanlist.get(i)==null)
continue;
chuanlist.get(i).changestate();
}
for (String eid : emap.keySet()) {
if (eid.matches("T\d+")) {
for (String id : ((Series) (emap.get(eid))).emap1.keySet()) {
if (emap.get(id) instanceof Hswitch) {
((Hswitch) emap.get(id)).changer();
}
else if(emap.get(id) instanceof Parallel)
{
((Parallel) emap.get(id)).changer();
}
else if(emap.get(id) instanceof Series)
{
for (String id1 : ((Series) (emap.get(id))).emap1.keySet()) {
if (emap.get(id1) instanceof Hswitch) {
((Hswitch) emap.get(id1)).changer();
}
else if(emap.get(id1) instanceof Parallel)
{
((Parallel) emap.get(id1)).changer();
}
if(!emap.get(id).changestate1(emap.get(eid))) {
emap.get(id).resistance=999999999;
break;
}
if (emap.containsKey(id1)) {
emap.get(id).resistance += emap.get(id1).resistance;
if(emap.get(id).resistance>=999999999)
{
break;
}
}
}
}
if(!emap.get(eid).changestate1(emap.get(eid))) {
emap.get(eid).resistance=999999999;
break;
}
if (emap.containsKey(id)) {
emap.get(eid).resistance += emap.get(id).resistance;
if(emap.get(eid).resistance>=999999999)
{
break;
}
}
}
}
else if (eid.matches("M\d+")) {
((Parallel) emap.get(eid)).changer();
}
}

    //輸出
    LinkedList<Equipment> elist = new LinkedList(emap.values());
    Equipment e = chuanlist.get(chuanlist.size() - 1);
    double v=220;
    for(String key:((Series)(e)).emap1.keySet())
    {
        Equipment a =  ((Series)(e)).emap1.get(key);
        if(a instanceof Devide)
        {
            v=((Devide)a).changeoutv(v);
        }
        else if(a instanceof Continue)
        {
            v=((Continue)a).changeoutv(v);
        }
        e.v = v;
        e.inv=v;
        break;
    }
    ((Series)e).changev();
    ((Series)e).changepin();
    if(Math.abs(e.resistance)>1e-10)
    {
        e.i =e.v / e.resistance;
        ((Series)e).changei();
    }
    for(Equipment ae:elist)
    {
        if(ae instanceof Bright)
        {
            ((Bright)ae).setlight(ae.v);
        }
        else if(ae instanceof Sun)
        {
            ((Sun)ae).setlight(ae.v);
        }
        else if(ae instanceof Fan)
        {
            ((Fan)ae).setrotate(ae.v);
        }
        else if(ae instanceof AFan)
        {
            ((AFan)ae).setrotate(ae.v);
        }
    }
    double light=0;
    for(int i=0;i<chuanlist.size();i++)
    {
        Series series = chuanlist.get(i);
        for(String str:series.emap1.keySet())
        {
            if(str.startsWith("B"))
            {
                light+=((Bright)series.emap1.get(str)).light;
            }
            else if(str.startsWith("R"))
            {
                light+=((Sun)series.emap1.get(str)).light;
            }
        }
    }
    for(int i=0;i<chuanlist.size();i++)
    {
        Series series = chuanlist.get(i);
        for(String str:series.emap1.keySet())
        {
            if(str.startsWith("S"))
            {
                ((S)series.emap1.get(str)).changeopenness(light);
            }
        }
    }
    Equipment t = elist.getLast();
    if(t.resistance==0)
    {
        System.out.println("short circuit error");
        return;
    }
    Collections.sort(elist,new comparator());
    for(Equipment e1:elist)
    {
        e1.display(e1);
        //System.out.println(e1.id+" "+e1.i);
    }
}

}
abstract class Equipment{
String type;
String id;
String pin;
double resistance=0;
double inv;
double outv;
double v;
double electricity;
double i;
boolean isreserve = false;
public Equipment(){}
public Equipment(String type,String id)
{
this.type=type;
this.id=id;
}
public Equipment(String type,String id,String pin){
this.type=type;
this.id=id;
this.pin=pin;
}
public abstract boolean changestate1(Equipment e);
public void changev(circuit s)
{
double allr = s.resistance;
double allv = s.v;
if(allr0)
{
v=0;resistance=0;
return;
}
if(allv>=999999999)
{
i=0;
v=0;
return;
}
v=resistance*allv/allr;
//System.out.println(id+" "+resistance);
}
public void changelinkpin(Equipment pre, circuit c)
{
double preVolt=0;
if(pre instanceof Hswitch)
{
if(pre.isreserve)
{
preVolt = pre.inv;
}
else
{
if(((Hswitch) pre).s2c)
{
preVolt = ((Hswitch) pre).s2v;
}
else if(((Hswitch) pre).s3c)
{
preVolt = ((Hswitch) pre).s3v;
}
}
}
else preVolt = pre.outv;
if(this instanceof Hswitch)
{
if(this.isreserve)
{
if(((Hswitch) this).s2c)
{
((Hswitch) this).s2v = preVolt;
}
else if(((Hswitch) this).s3==c)
{
((Hswitch) this).s3v = preVolt;
}
}
else
{
this.inv = preVolt;
}
}
else this.inv = preVolt;
}
public void changepin(circuit e)
{
if(changestate1(e))
{
if (this instanceof Hswitch)
{

            boolean isT2=(((Hswitch) this).s2 == e);
            boolean isT3=(((Hswitch) this).s3 == e);
            if (isreserve)
            {
                if (isT2)
                    this.inv = ((Hswitch) this).s2v - v;
                else if (isT3)
                    this.inv = ((Hswitch) this).s3v - v;
            }
            else
            {
                if (isT2)
                    ((Hswitch) this).s2v = inv - v;
                else if (isT3)
                    ((Hswitch) this).s3v = inv - v;
            }
            if(((Hswitch) this).s2v < 0)
                ((Hswitch) this).s2v = 0;
            if(((Hswitch) this).s3v < 0)
                ((Hswitch) this).s3v = 0;
        }
        outv = inv - v;
    }
    if (outv < 0)outv = 0;
}
public void changereserve()
{
    if(pin.equals("2"))
        isreserve=true;
    else
        isreserve=false;
}
public void display(Equipment e){
    if(!(e instanceof Hswitch)&&!(e instanceof Series)&&!(e instanceof Parallel))
        e.changereserve();
    if(type.equals("K"))
    {
        if(e.i>e.electricity) {
            if (((Switch) e).state == 0) {
                if(!isreserve)
                    System.out.println("@" + id + ":turned on" + String.format(" %d-%d", ((int) inv), ((int) outv)) + " exceeding current limit error");
                else
                    System.out.println("@" + id + ":turned on" + String.format(" %d-%d", ((int) outv), ((int) inv)) + " exceeding current limit error");
            }
            else if (((Switch) e).state == 1) {
                if (!isreserve)
                    System.out.println("@" + id + ":closed" + String.format(" %d-%d", ((int) inv), ((int) outv)) + " exceeding current limit error");
                else
                    System.out.println("@" + id + ":closed" + String.format(" %d-%d", ((int) outv), ((int) inv)) + " exceeding current limit error");
            }
        }
        else
        {
            if (((Switch) e).state == 0) {
                if (!isreserve)
                    System.out.println("@" + id + ":turned on" + String.format(" %d-%d", ((int) inv), ((int) outv)));
                else
                    System.out.println("@" + id + ":turned on" + String.format(" %d-%d", ((int) outv), ((int) inv)));
            }
            else if (((Switch) e).state == 1) {
                if (!isreserve)
                    System.out.println("@" + id + ":closed" + String.format(" %d-%d", ((int) inv), ((int) outv)));
                else
                    System.out.println("@" + id + ":closed" + String.format(" %d-%d", ((int) outv), ((int) inv)));
            }
        }
    }
    else if(type.equals("F"))
    {
        if(e.i>e.electricity) {
            if(!isreserve)
                System.out.println("@" + id + ":" + ((Devide) e).speedlevel+String.format(" %d-%d",((int)inv),((int)outv))+" exceeding current limit error");
            else
                System.out.println("@" + id + ":" + ((Devide) e).speedlevel+String.format(" %d-%d",((int) outv), ((int) inv))+" exceeding current limit error");
        }
        else
        {
            if(!isreserve)
                System.out.println("@" + id + ":" + ((Devide) e).speedlevel+String.format(" %d-%d",((int)inv),((int)outv)));
            else
                System.out.println("@" + id + ":" + ((Devide) e).speedlevel+String.format(" %d-%d",((int) outv), ((int) inv)));
        }
    }
    else if(type.equals("L"))
    {
        if(e.i>e.electricity) {
            if(!isreserve)
                System.out.println("@" + id + ":" + String.format("%.2f", ((Continue) e).parameter)+String.format(" %d-%d",((int)inv),((int)outv))+" exceeding current limit error");
            else
                System.out.println("@" + id + ":" + String.format("%.2f", ((Continue) e).parameter)+String.format(" %d-%d",((int)outv),((int)inv))+" exceeding current limit error");
        }
        else
        {
            if(!isreserve)
                System.out.println("@" + id + ":" + String.format("%.2f", ((Continue) e).parameter)+String.format(" %d-%d",((int)inv),((int)outv)));
            else
                System.out.println("@" + id + ":" + String.format("%.2f", ((Continue) e).parameter)+String.format(" %d-%d",((int)outv),((int)inv)));
        }
    }
    else if(type.equals("B"))
    {
        if(e.i>e.electricity) {
            if(!isreserve)
                System.out.println("@" + id + ":" + (int) Math.floor(((Bright) e).light)+String.format(" %d-%d",((int)inv),((int)outv))+" exceeding current limit error");
            else
                System.out.println("@" + id + ":" + (int) Math.floor(((Bright) e).light)+String.format(" %d-%d",((int)outv),((int)inv))+" exceeding current limit error");
        }
        else{
            if(!isreserve)
                System.out.println("@" + id + ":" + (int) Math.floor(((Bright) e).light)+String.format(" %d-%d",((int)inv),((int)outv)));
            else
                System.out.println("@" + id + ":" + (int) Math.floor(((Bright) e).light)+String.format(" %d-%d",((int)outv),((int)inv)));
        }
    }
    else if(type.equals("R"))
    {
        if(e.i>e.electricity) {
            if(!isreserve)
                System.out.println("@" + id + ":" + (int) Math.floor(((Sun) e).light)+String.format(" %d-%d",((int)inv),((int)outv))+" exceeding current limit error");
            else
                System.out.println("@" + id + ":" + (int) Math.floor(((Sun) e).light)+String.format(" %d-%d",((int)outv),((int)inv))+" exceeding current limit error");
        }
        else{
            if(!isreserve)
                System.out.println("@" + id + ":" + (int) Math.floor(((Sun) e).light)+String.format(" %d-%d",((int)inv),((int)outv)));
            else
                System.out.println("@" + id + ":" + (int) Math.floor(((Sun) e).light)+String.format(" %d-%d",((int)outv),((int)inv)));
        }
    }
    else if(type.equals("D"))
    {
        if(e.i>e.electricity) {
            if(!isreserve)
                System.out.println("@" + id + ":" + (int) Math.floor(((Fan) e).rotate)+String.format(" %d-%d",((int)inv),((int)outv))+" exceeding current limit error");
            else
                System.out.println("@" + id + ":" + (int) Math.floor(((Fan) e).rotate)+String.format(" %d-%d",((int)outv),((int)inv))+" exceeding current limit error");
        }
        else
        {
            if(!isreserve)
                System.out.println("@" + id + ":" + (int) Math.floor(((Fan) e).rotate)+String.format(" %d-%d",((int)inv),((int)outv)));
            else
                System.out.println("@" + id + ":" + (int) Math.floor(((Fan) e).rotate)+String.format(" %d-%d",((int)outv),((int)inv)));
        }
    }
    else if(type.equals("A"))
    {
        if(e.i>e.electricity) {
            if(!isreserve)
                System.out.println("@" + id + ":" + (int) Math.floor(((AFan) e).rotate)+String.format(" %d-%d",((int)inv),((int)outv))+" exceeding current limit error");
            else
                System.out.println("@" + id + ":" + (int) Math.floor(((AFan) e).rotate)+String.format(" %d-%d",((int)outv),((int)inv))+" exceeding current limit error");
        }
        else
        {
            if(!isreserve)
                System.out.println("@" + id + ":" + (int) Math.floor(((AFan) e).rotate)+String.format(" %d-%d",((int)inv),((int)outv)));
            else
                System.out.println("@" + id + ":" + (int) Math.floor(((AFan) e).rotate)+String.format(" %d-%d",((int)outv),((int)inv)));
        }
    }
    else if(type.equals("S1"))
    {
        if(e.i>e.electricity) {
            if(!isreserve)
                System.out.println("@" + id + ":" + ((S) e).openness+String.format(" %d-%d",((int)inv),((int)outv))+" exceeding current limit error");
            else
                System.out.println("@" + id + ":" + ((S) e).openness+String.format(" %d-%d",((int)outv),((int)inv))+" exceeding current limit error");
        }
        else
        {
            if(!isreserve)
                System.out.println("@" + id + ":" + ((S) e).openness+String.format(" %d-%d",((int)inv),((int)outv)));
            else
                System.out.println("@" + id + ":" + ((S) e).openness+String.format(" %d-%d",((int)outv),((int)inv)));
        }
    }
    else if(type.equals("P1"))
    {
        if(e.i>e.electricity){
            if(((P)e).state==1) {
                if(!isreserve)
                    System.out.println("@" + id + ":" + "conduction" + String.format(" %d-%d", ((int) inv), ((int) outv)) + " exceeding current limit error");
                else
                    System.out.println("@" + id + ":" + "conduction" + String.format(" %d-%d", ((int) outv), ((int) inv)) + " exceeding current limit error");
            }
            else {
                if(!isreserve)
                    System.out.println("@" + id + ":" + "cutoff" + String.format(" %d-%d", ((int) inv), ((int) outv)) + " exceeding current limit error");
                else
                    System.out.println("@" + id + ":" + "cutoff" + String.format(" %d-%d", ((int) outv), ((int) inv)) + " exceeding current limit error");
            }
        }
        else
        {
            if(((P)e).state==1) {
                if (!isreserve)
                    System.out.println("@" + id + ":" + "conduction" + String.format(" %d-%d", ((int) inv), ((int) outv)) );
                else
                    System.out.println("@" + id + ":" + "conduction" + String.format(" %d-%d", ((int) outv), ((int) inv)) );
            }
            else {
                if (!isreserve)
                    System.out.println("@" + id + ":" + "cutoff" + String.format(" %d-%d", ((int) inv), ((int) outv)) );
                else
                    System.out.println("@" + id + ":" + "cutoff" + String.format(" %d-%d", ((int) outv), ((int) inv)) );
            }
        }
    }
    else if (e instanceof Hswitch)
    {
        if (e.i > e.electricity){
                System.out.println("@" + id + ":" + ((Hswitch) e).state + String.format(" %d-%d-%d", (int)(e.inv), (int)((Hswitch) e).s2v, (int)((Hswitch) e).s3v) + " exceeding current limit error");
        }
        else {
            System.out.println("@" + id + ":" + ((Hswitch) e).state + String.format(" %d-%d-%d", (int)(e.inv), (int)((Hswitch) e).s2v, (int)((Hswitch) e).s3v));
        }
    }
}

protected void R_changelinkpin(Equipment ne, circuit c) {
    double neVolt=0;
    if(ne instanceof Hswitch)
    {
        if(ne.isreserve)
        {
            if(((Hswitch) ne).s2 == c)
            {
                neVolt = ((Hswitch) ne).s2v;
            }
            else if(((Hswitch) ne).s3 == c)
            {
                neVolt = ((Hswitch) ne).s3v;
            }
        }
        else
        {
            neVolt = ne.inv;
        }
    }
    else neVolt = ne.inv;
    if(this instanceof Hswitch)
    {
        if(this.isreserve)
        {
            this.inv = neVolt;
        }
        else
        {
            if(((Hswitch) this).s2.id == c.id)
            {
                ((Hswitch) this).s2v = neVolt;
            }
            else if(((Hswitch) this).s3.id == c.id)
            {
                ((Hswitch) this).s3v = neVolt;
            }
        }
    }
    else this.outv = neVolt;
}

protected void R_changepin(circuit e) {
    if(changestate1(e))
    {
        if(this instanceof Hswitch)
        {
            boolean isT2=false;
            boolean isT3=false;
            if(((Hswitch) this).s2!=null)
                isT2 = Objects.equals(((Hswitch) this).s2.id, e.id);
            if(((Hswitch) this).s3!=null)
                isT3= Objects.equals(((Hswitch) this).s3.id, e.id);
            if(isreserve)
            {
                if(isT2)
                    ((Hswitch) this).s2v = inv;
                else if(isT3)
                    ((Hswitch) this).s3v = inv;
            }
            else
            {
                if(isT2)
                    inv = ((Hswitch) this).s2v;
                else if(isT3)
                    inv = ((Hswitch) this).s3v;
            }
        }
        else
            inv = outv;
    }
}

}
class Switch extends Equipment{
int state;
public Switch(){

}
public Switch(String id,String pin){
    super("K",id,pin);
    this.state=0;
    this.resistance=0;
    this.electricity=20;
}

@Override
public boolean changestate1(Equipment e) {
    if(state==0)
        return false;
    else
        return true;
}

public void changestate(){
    if(state==0)
        state=1;
    else
        state=0;
}

}
class Devide extends Equipment{
int speedlevel;
public Devide(){}
public Devide(String id,String pin){
super("F",id,pin);
this.speedlevel=0;
this.resistance=0;
this.electricity=18;
}

@Override
public boolean changestate1(Equipment e) {
    return true;
}

public double changeoutv(double inv){
    double v=0;
    if(speedlevel>=0)
    {
        switch(speedlevel)
        {
            case 0:v=inv*0;break;
            case 1:v=inv*0.3;break;
            case 2:v=inv*0.6;break;
            case 3:v=inv*0.9;break;
            default:v=inv*0.9;speedlevel=3;break;
        }
    }
    else
        speedlevel=0;
    return v;
}

}
class Continue extends Equipment{
double parameter;
public Continue(){}
public Continue(String id,String pin){
super("L",id,pin);
this.parameter=0;
this.resistance=0;
}

@Override
public boolean changestate1(Equipment e) {
    return true;

}

public void setparameter(double p){
    this.parameter=p;
}
public double changeoutv(double inv)
{
    double v;
    if(parameter<0||parameter>1)
        return 0;
    else{
        if(inv==0)
            v=0;
        else
        {
            v=inv*parameter;
        }
    }
    return v;
}

}
class Bright extends Equipment{
double light;
public Bright(){}
public Bright(String id,String pin){
super("B",id,pin);
this.light=0;
this.resistance=10.0000000000000001;
this.electricity=9;
}

@Override
public boolean changestate1(Equipment e) {
    return true;
}

public void setlight(double inv){
    //System.out.println(inv);
    if(inv>=0&&inv<=9)
        light=0;
    else if(inv>9&&inv<220)
    {
        light=5*(inv-10)/7+50;
    }
    else
        light=200;
}

}
class Sun extends Equipment{
double light;
public Sun(){}
public Sun(String id,String pin){
super("R",id,pin);
this.light=0;
this.resistance=5;
this.electricity=5;
}

@Override
public boolean changestate1(Equipment e) {
    return true;
}

public void setlight(double v){
    if(v==0)
        this.light=0;
    else
        this.light=180;
}

}
class Fan extends Equipment{
double rotate;
public Fan(){}
public Fan(String id,String pin){
super("D",id,pin);
this.rotate=0;
this.resistance=20;
this.electricity=12;
}

@Override
public boolean changestate1(Equipment e) {
    return true;
}

public void setrotate(double inv){

//System.out.println(inv);
if(inv<80)
this.rotate=0;
else
{
if(inv>=80&&inv<=150)
this.rotate=4*(inv-80)+80;
else if(inv>150)
this.rotate=360;
}
//System.out.println(rotate);
}
}
class AFan extends Equipment{
double rotate;
public AFan(){}
public AFan(String id,String pin){
super("A",id,pin);
this.rotate=0;
this.resistance=20;
this.electricity=14;
}

@Override
public boolean changestate1(Equipment e) {
    return true;
}

public void setrotate(double inv){

//System.out.println(id+inv);
if(inv<80)
this.rotate=0;
else
{
if(inv>=80&&inv<=99)
this.rotate=80;
else if(inv>99&&inv<120)
this.rotate=160;
else if(inv>=120&&inv<140)
this.rotate=260;
else if(inv>=140)
this.rotate=360;
}
}
}
class Hswitch extends Equipment{
double s2v=0;
double s3v=0;
String state = "closed";
Series s2=null;
Series s3=null;
boolean ison2 ;
public Hswitch(String id){
super("H",id);
ison2 = false ;
this.electricity=20;
}
public void change()
{
ison2 = !ison2;
}
public void changer()
{
this.resistance = (ison2?10:5);
state = (ison2?"turned on":"closed");
}

@Override
public boolean changestate1(Equipment e) {
    if(!(e instanceof circuit)) {
        return false;
    }
    if(!ison2)
        return (s2==e);
    else
        return (s3==e);

}

}
class S extends Equipment{
String openness;
public S(String id,String pin){
super("S1",id,pin);
this.resistance=15;
this.electricity=12;
}

@Override
public boolean changestate1(Equipment e) {
    return true;
}

public void changeopenness(double light)
{
    if(inv<50)
    {
        openness = "100%";
    }
    else if(inv>=50)
    {
        if(0<=light&&light<50)
        {
            openness="100%";
        }
        if(light>=50&&light<100)
        {
            openness = "80%";
        }
        else if(light>=100&&light<200)
        {
            openness = "60%";
        }
        else if(light>=200&&light<300)
        {
            openness = "40%";
        }
        else if(light>=300&&light<400)
        {
            openness = "20%";
        }
        else
            openness = "0%";
    }
}

}
class P extends Equipment{
int state;
public P(String id,String pin)
{
super("P1",id,pin);
this.electricity=8;
this.state=1;
this.resistance=0;
}

@Override
public boolean changestate1(Equipment e) {
    if(state==1)
    {
        return true;
    }
    else
    {
        return false;
    }

}

}
abstract class circuit extends Equipment{
int state;
LinkedHashMap <String,Equipment> emap1 = new LinkedHashMap<>();
LinkedList eList;
public circuit(String type,String id)
{
super(type,id);
}
public void getlist()
{
eList = new LinkedList<>(this.emap1.values());
}
public abstract void changev();
public abstract void changei();
public abstract void changepin();
}
//series-parallel
//串聯
class Series extends circuit{
public Series(String id){
super("S",id);
this.state=0;
}
public void changestate() {
for (String id : emap1.keySet()) {
if (id.matches("K\d+")) {
//System.out.println(((Switch)semap.get(id)).state);
if (((Switch) emap1.get(id)).state == 0)
this.state = 1;
}
}
for(String key:emap1.keySet())
{
if(key.startsWith("H"))
{
if((!((Hswitch)emap1.get(key)).ison2)&&((Hswitch)emap1.get(key)).s3!=null)
((Hswitch)emap1.get(key)).s3.state=1;
if(((Hswitch)emap1.get(key)).ison2&&((Hswitch)emap1.get(key)).s2!=null)
((Hswitch)emap1.get(key)).s2.state=1;
}
else if(key.startsWith("P"))
{
if(emap1.get(key).pin.equals("2"))
{
((P)emap1.get(key)).state=0;
emap1.get(key).resistance=999999999;
}
}
}
for (String id : emap1.keySet()) {
if(id.matches("P\d+"))
{
if(((P) emap1.get(id)).state == 0)
this.state = 1;
}
}
for(String key : emap1.keySet())
{
if(key.startsWith("T"))
{
if(((Series)emap1.get(key)).state1)
this.state=1;
}
}
for(String key : emap1.keySet())
{
if(key.startsWith("T"))
{
if(state1)
{
((Series)emap1.get(key)).state=1;
}
}
}
}

@Override
public void changev() {
    for(String key:emap1.keySet())
    {
        emap1.get(key).changev(this);
        if(emap1.get(key) instanceof circuit)
            ((circuit)emap1.get(key)).changev();
    }
}

@Override
public void changei() {
    if(!changestate1(this))return;
    for(String key:emap1.keySet())
    {
        Equipment e = emap1.get(key);
        //System.out.println(e.id+" "+e.state1);
        if(e.changestate1(this)) {
            e.i = i;
            //System.out.println(e.id+" "+e.i);
        }
        if(e instanceof circuit)
            ((circuit) e).changei();
    }
}

@Override
public void changepin() {
    getlist();
    Equipment t = eList.getFirst();
    if(t instanceof Hswitch && t.isreserve)
    {
        if(((Hswitch) t).s2.id == id)
            ((Hswitch) t).s2v = inv;
        else ((Hswitch) t).s3v = inv;
    }
    else t.inv = inv;
    t.changepin(this);
    if(t instanceof circuit)
        ((circuit) t).changepin();
    for(int i=1;i< eList.size();i++)
    {
        Equipment e = eList.get(i);
        e.changelinkpin(t,this);
        e.changepin(this);
        t = e;
        if(e instanceof circuit)
            ((circuit) e).changepin();
    }
    //倒著掃一遍更新斷路開關後面的裝置電勢
    if(!changestate1(this))
    {
        t = eList.getLast();
        if (t instanceof Hswitch)
        {
            if (t.isreserve) t.inv = outv;
            else
            {
                if (((Hswitch) t).s2.id == id)
                    ((Hswitch) t).s2v = outv;
                else ((Hswitch) t).s2v = outv;
            }
        }
        else t.outv = outv;
        t.R_changepin(this);
        if(t instanceof circuit)
            ((circuit) t).changepin();
        for (int i = eList.size() - 2; i >= 0; i--)
        {
            Equipment e = eList.get(i);
            e.R_changelinkpin(t,this);
            if(!e.changestate1(this))
                break;
            e.R_changepin(this);
            t = e;
            if(e instanceof circuit)
                ((circuit) e).changepin();
        }
    }
}

@Override
public boolean changestate1(Equipment e) {
    getlist();
    for(Equipment t:eList)
    {
        if(!t.changestate1(this)) {
            return false;
        }
    }
    return true;
}

}
//並聯
class Parallel extends circuit{
int shortnum;
public Parallel(String id){
super("P",id);
this.resistance=0;
}
public void changer()
{
double r=0;
if(!changestate1(this))
{
resistance=999999999;
return;
}
for(String s:emap1.keySet())
{
if(emap1.get(s).changestate1(emap1.get(s)))
{
if (Math.abs(emap1.get(s).resistance) < 1e-10)
{
resistance = 0;
return;
}
r+=1/emap1.get(s).resistance;
}
}
if(Math.abs(r) < 1e-10)
{
resistance=999999999;
return;
}
this.resistance=1/r;
//System.out.println(this.resistance);
}

@Override
public void changev() {
    boolean flag = false;
    for(String key:emap1.keySet())
    {
        Equipment e = emap1.get(key);
        if(((Series)e).state==1)continue;
        e.v = v;
        if(e instanceof circuit)
        {
            ((circuit) e).changev();
        }
        if(e.resistance == 0)
        {
            flag = true;
            shortnum ++;//短路
        }
    }
    if(flag)
    {
        for(String key:emap1.keySet())
        {
            Equipment e = emap1.get(key);
            e.v = 0;
        }
    }
}

@Override
public void changei() {

    for(String key:emap1.keySet())
    {
        Equipment e = emap1.get(key);
        if(Math.abs(resistance)<1e-10)
        {
            if(Math.abs(e.resistance)<1e-10)
                e.i =i/ shortnum;
            else e.i = 0;
        }
        else
        {
            e.i = v / e.resistance;
        }
        if (e instanceof circuit)
            ((circuit) e).changei();
        //System.out.println(e.id+" "+e.i);
    }
}
@Override
public void changepin() {
    for(String key:emap1.keySet())
    {
        emap1.get(key).inv=inv;
        emap1.get(key).outv=outv;

        if(emap1.get(key) instanceof circuit)
            ((circuit)emap1.get(key)).changepin();
    }
}

@Override
public boolean changestate1(Equipment e) {
    getlist();
    for(Equipment t:eList)
    {
        if(t.changestate1(this)) {
            return true;
        }
    }
    return false;
}

}

class comparator implements Comparator{
private static final List order = Arrays.asList('K', 'F', 'L', 'B', 'R', 'D','A','H','S','P');
@Override
public int compare(Equipment o1, Equipment o2) {
String key1 = o1.id;
String key2 = o2.id;
int order1 = order.indexOf(key1.charAt(0));
int order2 = order.indexOf(key2.charAt(0));
if (order1 != order2) {
return order1 - order2;
}
else
{
return key1.compareTo(key2);
}
}
}
總結：
透過這次作業我學到了，例如:繼承的使用方法、注意事項及性質，多型的實現途徑及多型的主要作用，介面的實現方法、使用時的注意事項及多型的性質。在本次作業中，還是發現了很多在編寫程式碼時的不足之處，不能耐下心來先想好寫題思路再動手寫題，而是直接動手，邊寫邊想後面的思路，導致總是寫著寫著就得重新寫前面有衝突的程式碼，我也會積極改正，在以後寫複雜的程式碼時先想好整體思路在進行程式編寫。

23201421-PTA第7，8次大作業總結-第三次Bolg

+裝置標識K+裝置編號，例如：#K2，代表切換K2開關的狀態。

+裝置標識H+裝置編號，例如：#H2，代表切換H2互斥開關的狀態。

+裝置標識F+裝置編號+"+" 代表加一檔，例如：#F3+，代表F3輸出加一檔。

+裝置標識F+裝置編號+"-" 代表減一檔，例如：#F1-，代表F1輸出減一檔。

+裝置標識L+裝置編號+":" +數值 代表將連續調速器的檔位設定到對應數值，例如：#L3:0.6，代表L3輸出檔位引數0.6。

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT OUT]

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT M2-IN] [M2-OUT OUT]

T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]

T1:[IN H1-1] [H1-2 D2-1] [D2-2 OUT]

T2:[IN H1-1] [H1-3 D1-1] [D1-2 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 B2-1] [B2-2 OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T3:[VCC K2-1] [K2-2 M1-IN] [M1-OUT M2-IN] [M2-OUT GND]

K1

K2

T1:[IN D2-1] [D2-2 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 B2-1] [B2-2 OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T3:[VCC K2-1] [K2-2 M1-IN] [M1-OUT M2-IN] [M2-OUT GND]

K1

K2

T1:[IN K1-1] [K1-2 B2-1] [B2-2 OUT]

T2:[IN K2-1] [K2-2 R1-1] [R1-2 OUT]

M1:[T1 T2]

T3:[VCC K3-1] [K3-2 M1-IN] [M1-OUT S1-1] [S1-2 GND]

K1

K2

K3

T1:[IN K2-1] [K2-2 D2-1] [D2-2 OUT]

T2:[IN K3-1] [K3-2 D1-1] [D1-2 OUT]

T3:[VCC K1-1] [K1-2 T1-IN] [T1-OUT T2-IN] [T2-OUT GND]

K1

K2

K3

T3:[VCC B2-1] [B2-2 K1-1] [K1-2 S1-1] [S1-2 H1-1] [H1-2 GND]

K1

+裝置標識K+裝置編號，例如：#K2，代表切換K2開關的狀態。

+裝置標識H+裝置編號，例如：#H2，代表切換H2互斥開關的狀態。

+裝置標識F+裝置編號+"+" 代表加一檔，例如：#F3+，代表F3輸出加一檔。

+裝置標識F+裝置編號+"-" 代表減一檔，例如：#F1-，代表F1輸出減一檔。

+裝置標識L+裝置編號+":" +數值 代表將連續調速器的檔位設定到對應數值，例如：#L3:0.6，代表L3輸出檔位引數0.6。

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT OUT]

T1:[IN K1-1] [K1-2 T2-IN] [T2-OUT M2-IN] [M2-OUT OUT]

T3:[VCC K1-1] [K1-2 T2-IN] [T2-OUT K2-1] [K2-2 T1-IN] [T1-OUT GND]

T1:[IN D2-1] [D2-2 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T1:[IN P2-2] [P2-1 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T3:[VCC K2-1] [K2-2 M2-IN] [M2-OUT GND]

K1

K2

T1:[IN P2-1] [P2-2 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

M2:[T4 T5]

T3:[VCC K2-1] [K2-2 M2-IN] [M2-OUT GND]

K1

K3

K2

T1:[IN P2-2] [P2-1 H1-2] [H1-1 OUT]

T2:[IN D1-1] [D1-2 H1-3] [H1-1 OUT]

M1:[T1 T2]

T4:[IN K3-1] [K3-2 M1-IN] [M1-OUT OUT]

T5:[IN K1-1] [K1-2 B1-1] [B1-2 OUT]

+裝置標識L+裝置編號+":" +數值代表將連續調速器的檔位設定到對應數值，例如：#L3:0.6，代表L3輸出檔位引數0.6。

+裝置標識L+裝置編號+":" +數值代表將連續調速器的檔位設定到對應數值，例如：#L3:0.6，代表L3輸出檔位引數0.6。