1）前言：對於最後這兩次的題，難度明顯比前兩次要難上許多，在之前的基礎上新增了許多的類和電路圖變得更加的複雜化了，需要考慮的電路更加複雜
（2）設計與分析：
題集7：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中所示的互斥開關可以反過來接入電路，即彙總引腳接往接地端，兩個分支引腳接往電源端。
image.png
圖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%
該題在二的基礎上新增了互斥開關跟窗簾，還有可以串聯串串聯
我的程式碼為：import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Text {
private static Integer extractNumber(String name) {
return Integer.parseInt(name.replaceAll("\D", ""));
}
public static void show(List
Map<String, List
Map<String, List
for (Kai k : kai) {
String className = getClassIdentifier(k);
kaiMap.computeIfAbsent(className, key -> new ArrayList<>()).add(k);
}
for (Dianqi d : dianqi) {
String className = getClassIdentifier(d);
dianqiMap.computeIfAbsent(className, key -> new ArrayList<>()).add(d);
}
for (String className : Arrays.asList("K", "F", "L")) {
List<Kai> kList = kaiMap.get(className);
if (kList != null) {
Collections.sort(kList, Comparator.comparingInt(k -> extractNumber(k.getName())));
for (Kai k : kList) {
k.show();
}
}
}
for (String className : Arrays.asList("B", "R", "D", "A")) {
List<Dianqi> dList = dianqiMap.get(className);
if (dList != null) {
Collections.sort(dList, Comparator.comparingInt(d -> extractNumber(d.getName())));
for (Dianqi d : dList) {
d.show();
}
}
}
for (String className : Arrays.asList("H")) {
List<Kai> kList = kaiMap.get(className);
if (kList != null) {
Collections.sort(kList, Comparator.comparingInt(k -> extractNumber(k.getName())));
for (Kai k : kList) {
if(k.getName().substring(k.getName().length()-1).contains("3")) {
continue;
}
k.show();
}
}
}
for (String className : Arrays.asList("S")) {
List<Dianqi> dList = dianqiMap.get(className);
if (dList != null) {
Collections.sort(dList, Comparator.comparingInt(d -> extractNumber(d.getName())));
for (Dianqi d : dList) {
d.show();
}
}
}
}
private static String getClassIdentifier(Object obj) {
if (obj instanceof Kai) {
Kai kai = (Kai) obj;
return kai.getClass().getSimpleName();
} else if (obj instanceof Dianqi) {
Dianqi dianqi = (Dianqi) obj;
return dianqi.getClass().getSimpleName();
}
return null;
}
public static boolean isduan(List<Kai> kai) {
for(Kai kais:kai) {
if((kais).getA()==0) {
return false;
}
}
return true;
}
public static int dianzu(List<Dianqi>dianqi) {
int a=0;
for(Dianqi dianqis:dianqi) {
a+=dianqis.getdianzu();
}
return a;
}
public static void setchuan(List<Dianqi>dianqi) {
for(Dianqi dian:dianqi) {
if(dianqi instanceof S) {
S s=(S)dian;
s.setchuang(dianqi);
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in=new Scanner(System.in);
String input;
ArrayList<T> tss=new ArrayList<>();
ArrayList<Kai> kai=new ArrayList<>();
ArrayList<Dianqi> dianqi=new ArrayList<>();
ArrayList<M> m=new ArrayList<>();
while(!( input = in.nextLine()).equals("end"))
{
if(input.startsWith("#T"))
{
String part=input.substring(1,3);
T t1=new T(part);
tss.add(t1);
Pattern pattern = Pattern.compile("\\[(.*?) (.*?)\\]");
Matcher matcher = pattern.matcher(input);
while(matcher.find()) {
String to=matcher.group(2);
if(to.startsWith("K")) {
K k=new K(to.substring(0, 2));
kai.add(k);
t1.setKai(k);
}
else if(to.startsWith("F")) {
F f=new F(to.substring(0, 2));
kai.add(f);
t1.setKai(f);
}
else if(to.startsWith("L")) {
L l=new L(to.substring(0, 2));
//l.setName(to.substring(0, 2));
kai.add(l);
t1.setKai(l);
}
else if(to.startsWith("B")) {
B b=new B(to.substring(0, 2));
dianqi.add(b);
// t1.setDianzu(10);
t1.setDian(b);
}
else if(to.startsWith("R")) {
R r=new R(to.substring(0, 2));
dianqi.add(r);
// t1.setDianzu(5);
t1.setDian(r);
}
else if(to.startsWith("D")) {
D d=new D(to.substring(0, 2));
dianqi.add(d);
// t1.setDianzu(20);
t1.setDian(d);
}
else if(to.startsWith("A")) {
A a=new A(to.substring(0, 2));
dianqi.add(a);
// t1.setDianzu(20);
t1.setDian(a);
}
else if(to.contains("M")) {
for(M ms:m) {
if(ms.getName().contains(to.substring(0, 2))) {
t1.setM(ms);
}
}
}
else if(to.startsWith("H")){
H h=new H(to);
// for(Kai kais:kai) {
// if(kais instanceof H) {
// if(kais.getName().contains(h.name)) {
// h.gai();
// }
// }
// }
if(to.substring(to.length()-1).contains("2")) {
h.gai();
}
else {
h.gai();
}
kai.add(h);
t1.setKai(h);
}
else if(to.startsWith("T")) {
for(T ts:tss) {
if(ts.name.contains(to.substring(0, 2))) {
t1.setT(ts);
}
}
}
else if(to.startsWith("S")) {
S s=new S(to.substring(0, 2));
dianqi.add(s);
t1.setDian(s);
}
}
}
else if(input.startsWith("#M")) {
Pattern pattern = Pattern.compile("#M\d+:\[(.*?)]");
Matcher matcher = pattern.matcher(input);
String ma=input.substring(1,3);
M ms=new M(ma);
m.add(ms);
if (matcher.find()) {
String content = matcher.group(1);
String[] parts = content.split(" ");
// for(int i=0;i<parts.length;i++) {
// ms.addT(t.get(i));
// }
for(int i=0;i<parts.length;i++) {
for(T ts:tss) {
if(ts.name.contains(parts[i])) {
ms.addT(ts);
}
}
}
}
}
else if(input.startsWith("#K")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof K) {
K kk=(K) kais;
if(kk.getName().contains(k)) {
kk.gai();
}
}
}
}
else if(input.startsWith("#F")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof F)
{
F kk=(F) kais;
if(kk.getName().contains(k)) {
if(input.contains("+")) {
kk.jiaF();
}
else if(input.contains("-")) {
kk.jianF();
}
}
}
}
}
else if(input.startsWith("#L")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof L) {
L kk=(L) kais;
if(kk.getName().contains(k)) {
String ae=input.substring(4,input.length());
double a=Double.parseDouble(ae);
kk.setA(a);
}
}
}
}
else if(input.startsWith("#H")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof H) {
H kk=(H) kais;
if(kk.getName().contains(k)) {
kk.gai();
}
}
}
}
}
T tt=tss.get(tss.size()-1);
if(tt.kai.isEmpty()) {
double aa=0;
if(m.isEmpty()) {
if(tss.size()==1) {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return ;
}
else {
double a=dianzu(tt.dian);
for(int i=0;i<tt.kai.size();i++) {
if(tt.kai.get(i) instanceof H) {
H hj=(H) tt.kai.get(i);
a+=hj.getDianzu();
}
}
double dianliu=220.0/a;
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
setchuan(dianqi);
show(kai,dianqi);
return;
}
}
else {
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
if(!isduan(gi.kai)) {
show(kai,dianqi);
return ;
}
}
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
aa+=gi.dian.get(i).getdianzu();
}
for(int l=0;l<gi.kai.size();l++) {
if(gi.kai.get(l) instanceof H) {
H h=(H)gi.kai.get(l);
aa+=h.getDianzu();
}
}
}
double dianliu=220.0/aa;
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
gi.dian.get(i).setzhuangtai(dianliu*gi.dian.get(i).getdianzu());
}
}
setchuan(dianqi);
show(kai,dianqi);
return;
}
}
else {
if(!tt.t.isEmpty())
{
for(T ts:tt.t) {
if(!isduan(ts.kai)) {
show(kai,dianqi);
return;
}
}
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai k:td.kai) {
if(k instanceof H) {
H h=(H)k;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(T ij:tt.t) {
for(Dianqi ik:ij.dian) {
aa+=ik.getdianzu();
}
for(Kai k:ij.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai k:tt.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
double dianliu=220.0/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
show(kai,dianqi);
return;
}
else {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai k:td.kai) {
if(k instanceof H) {
H h=(H)k;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai k:tt.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
double dianliu=220.0/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
show(kai,dianqi);
return;
}
}
}
else if(tt.kai.get(0) instanceof K) {
double aa=0;
if(m.isEmpty()) {
if(tss.size()==1) {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return ;
}
else {
double a=dianzu(tt.dian);
for(int i=0;i<tt.kai.size();i++) {
if(tt.kai.get(i) instanceof H) {
H hj=(H) tt.kai.get(i);
//a+=hj.getDianzu();
a+=5;
}
}
double dianliu=220.0/a;
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
if(!isduan(gi.kai)) {
show(kai,dianqi);
return ;
}
}
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
aa+=gi.dian.get(i).getdianzu();
}
for(int l=0;l<gi.kai.size();l++) {
if(gi.kai.get(l) instanceof H) {
H h=(H)gi.kai.get(l);
aa+=h.getDianzu();
}
}
}
double dianliu=220.0/aa;
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
gi.dian.get(i).setzhuangtai(dianliu*gi.dian.get(i).getdianzu());
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
if(!tt.t.isEmpty())
{
for(T ts:tt.t) {
if(!isduan(ts.kai)) {
show(kai,dianqi);
return;
}
}
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai k:td.kai) {
if(k instanceof H) {
H h=(H)k;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(T ij:tt.t) {
for(Dianqi ik:ij.dian) {
aa+=ik.getdianzu();
}
for(Kai k:ij.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai k:tt.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
double dianliu=220.0/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
else {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai k:td.kai) {
if(k instanceof H) {
H h=(H)k;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai k:tt.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
double dianliu=220.0/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
}
else if(tt.kai.get(0) instanceof F) {
F k=(F)tt.kai.get(0);
double as=k.getA();
if(as==0) {
show(kai,dianqi);
}
else {
double aa=0;
if(m.isEmpty()) {
if(tss.size()==1) {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return ;
}
else {
double a=dianzu(tt.dian);
for(int i=0;i<tt.kai.size();i++) {
if(tt.kai.get(i) instanceof H) {
H hj=(H) tt.kai.get(i);
a+=hj.getDianzu();
}
}
double dianliu=(as*220.0)/a;
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
if(!isduan(gi.kai)) {
show(kai,dianqi);
return ;
}
}
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
aa+=gi.dian.get(i).getdianzu();
}
for(int l=0;l<gi.kai.size();l++) {
if(gi.kai.get(l) instanceof H) {
H h=(H)gi.kai.get(l);
aa+=h.getDianzu();
}
}
}
double dianliu=(as*220.0)/aa;
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
gi.dian.get(i).setzhuangtai(dianliu*gi.dian.get(i).getdianzu());
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
if(!tt.t.isEmpty())
{
for(T ts:tt.t) {
if(!isduan(ts.kai)) {
show(kai,dianqi);
return;
}
}
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai ks:td.kai) {
if(ks instanceof H) {
H h=(H)ks;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(T ij:tt.t) {
for(Dianqi ik:ij.dian) {
aa+=ik.getdianzu();
}
for(Kai ks:ij.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai ks:tt.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
double dianliu=(as*220.0)/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
else {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai ks:td.kai) {
if(ks instanceof H) {
H h=(H)ks;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai ks:tt.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
double dianliu=(as*220.0)/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return ;
}
}
}
}
else if(tt.kai.get(0) instanceof L) {
L k=(L)tt.kai.get(0);
double as=k.getA();
if(as==0) {
show(kai,dianqi);
}
else {
double aa=0;
if(m.isEmpty()) {
if(tss.size()==1) {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return ;
}
else {
double a=dianzu(tt.dian);
for(int i=0;i<tt.kai.size();i++) {
if(tt.kai.get(i) instanceof H) {
H hj=(H) tt.kai.get(i);
a+=hj.getDianzu();
}
}
double dianliu=(as*220.0)/a;
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
if(!isduan(gi.kai)) {
show(kai,dianqi);
return ;
}
}
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
aa+=gi.dian.get(i).getdianzu();
}
for(int l=0;l<gi.kai.size();l++) {
if(gi.kai.get(l) instanceof H) {
H h=(H)gi.kai.get(l);
aa+=h.getDianzu();
}
}
}
double dianliu=(as*220.0)/aa;
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
gi.dian.get(i).setzhuangtai(dianliu*gi.dian.get(i).getdianzu());
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
if(!tt.t.isEmpty())
{
for(T ts:tt.t) {
if(!isduan(ts.kai)) {
show(kai,dianqi);
return;
}
}
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai ks:td.kai) {
if(ks instanceof H) {
H h=(H)ks;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(T ij:tt.t) {
for(Dianqi ik:ij.dian) {
aa+=ik.getdianzu();
}
for(Kai ks:ij.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai ks:tt.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
double dianliu=(as*220.0)/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
else {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai ks:td.kai) {
if(ks instanceof H) {
H h=(H)ks;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai ks:tt.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
double dianliu=(as*220.0)/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
}
}
}
}
class T{
String name;
int dianzu;
public ArrayList
public ArrayList< Dianqi> dian;
public ArrayList
public ArrayList
void setDianzu(int dianzu) {
this.dianzu=dianzu;
}
double getDianzu(){
return dianzu;
}
void setM(M m) {
this.m.add(m);
}
T(){
}
T(String name){
this.name=name;
this.dian=new ArrayList<>();
this.kai=new ArrayList<>();
}
void setDian(Dianqi dian) {
this.dian.add(dian);
}
void setKai(Kai kai) {
this.kai.add(kai);
}
void setT(T ts) {
this.t.add(ts);
}
}
class M{
String name;
double dianzu;
ArrayList<T> chuan;
M(){
}
M(String name){
this.name=name;
this.chuan=new ArrayList<>();
}
void addT(T t) {
this.chuan.add(t);
}
double getDianzu() {
double b = 0;
for(T chuans:chuan) {
for (Kai chaunss : chuans.kai) {
if (!isduan(chaunss)) { // Only add resistance if the switch is not disconnected
b += (1.0 / chuans.getDianzu());
}
}
}
if (b == 0) { // Avoid division by zero
return Double.MAX_VALUE;
}
return 1.0 / b;
}
boolean isduan(Kai kai) {
if (kai instanceof K) {
return ((K) kai).getA() == 0; // 0 means turned on
} else if (kai instanceof F) {
return ((F) kai).getA() == 0;
} else if (kai instanceof L) {
return ((L) kai).getA() == 0;
}
return true; // Default to assume it's open
}
String getName() {
return name;
}
}
abstract class Kai{
abstract void show();
abstract String getName();
abstract double getA();
}
class K extends Kai{
String name;
double a=0;
void gai() {
if(a0) {
a=1;
}
else if(a1) {
a=0;
}
}
public void show(){
if(a1) {
System.out.println("@"+name+":closed");
}
else if(a0)
{
System.out.println("@"+name+":turned on");
}
}
K(){
}
K(String name){
this.name=name;
}
double getA() {
return a;
}
String getName() {
return name;
}
}
class F extends Kai{
String name;
double a=0.0;
F(){
}
F(String name){
this.name=name;
}
void jiaF() {
this.a+=0.3;
}
void jianF() {
this.a-=0.3;
}
public void show() {
int ds=0;
if(a==0) {
ds=0;
}
else if(a==0.3) {
ds=1;
}
else if(a==0.6) {
ds=2;
}
else {
ds=3;
}
String sd=Integer.toString(ds);
System.out.println("@"+name+":"+sd);
}
double getA() {
return a;
}
String getName() {
return name;
}
}
class L extends Kai{
String name;
double a;
L(){
}
L(String name)
{
this.name=name;
this.a=0;
}
void setName(String name) {
this.name=name;
}
String getName() {
return name;
}
void setA(double a) {
this.a=a;
}
double getA() {
return a;
}
public void show() {
String abs=String.format("%.2f",a);
System.out.println("@"+name+":"+abs);
}
}
class H extends Kai{
String name;
int op=0;
H(){
}
H(String name){
this.name=name;
}
void gai() {
if(op==0) {
op=1;
}
else if(op==1) {
op=0;
}
}
@Override
void show() {
// TODO Auto-generated method stub
if(op==1) {
System.out.println("@"+name.subSequence(0, 2)+":closed");
}
else if(op==0)
{
System.out.println("@"+name.subSequence(0, 2)+":turned on");
}
}
@Override
String getName() {
return name;
}
double getDianzu() {
if(op==1&&name.substring(name.length()-1).contains("2")) {
return 5.0;
}
else if(op==1&&name.substring(name.length()-1).contains("3"))
{
return 10.0;
}
return 0;
}
@Override
double getA() {
return op;
}
}
abstract class Dianqi{
String name;
abstract void show();
abstract String getName();
abstract void setzhuangtai(double a);
abstract int getdianzu();
}
class B extends Dianqi{
double liang;
int dianzu=10;
B(){
}
B(String name){
this.name=name;
this.liang=0;
}
int getdianzu() {
return dianzu;
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(liang));
}
void setLiang(double liang) {
this.liang=liang;
}
void setzhuangtai(double a) {
if(a>=0&&a<10) {
this.liang=0;
}
else if(a>=10&&a<=220) {
double l=5.0/7;
double ll=300.0/7;
double lll=l*a+ll;
this.liang=lll;
}
}
String getName() {
return name;
}
double getLiang() {
return liang;
}
}
class R extends Dianqi{
double liang;
int dianzu=5;
R(){
}
R(String name){
this.name=name;
this.liang=0;
}
int getdianzu() {
return dianzu;
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(liang));
}
void setLiang(double liang) {
this.liang=liang;
}
void setzhuangtai(double a) {
if(a==0) {
this.liang=0;
}
else {
this.liang=180;
}
}
String getName() {
return name;
}
double getLiang() {
return liang;
}
}
class D extends Dianqi{
double zhuan;
int dianzu=20;
D(){
}
D(String name){
this.name=name;
this.zhuan=0;
}
int getdianzu() {
return dianzu;
}
void setZhuan(double zhuan) {
this.zhuan=zhuan;
}
void setzhuangtai(double a) {
if(a>=0&&a<80) {
this.zhuan=0;
}
else if(a>=80&&a<=150) {
double y=4.0*a-240.0;
this.zhuan=y;
}
else if(a>150&&a<=220) {
this.zhuan=360;
}
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(zhuan));
}
String getName() {
return name;
}
}
class A extends Dianqi{
double zhuan;
int dianzu=20;
A(){
}
A(String name){
this.name=name;
this.zhuan=0;
}
int getdianzu() {
return dianzu;
}
void setZhuan(double zhuan) {
this.zhuan=zhuan;
}
void setzhuangtai(double a) {
if(a>=0&&a<80) {
this.zhuan=0;
}
else if(a>=80&&a<100) {
this.zhuan=80;
}
else if(a>=100&&a<120) {
this.zhuan=160;
}
else if(a>=120&&a<140) {
this.zhuan=260;
}
else if(a>=140&&a<=220) {
this.zhuan=360;
}
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(zhuan));
}
String getName() {
return name;
}
}
class S extends Dianqi{
double gu;
S(){
}
S(String name){
this.name=name;
this.gu=0;
}
@Override
void show() {
int ab=(int)(gu*100);
System.out.println("@"+name+":"+ab+"%");
}
@Override
String getName() {
return name;
}
@Override
void setzhuangtai(double a) {
if(a>=0&&a<50) {
this.gu=1.0;
}
else {
this.gu=0;
}
}
void setchuang(List<Dianqi> dianqi) {
double op=0;
for(Dianqi dianqis:dianqi) {
if(dianqis instanceof B) {
B b=(B)dianqis;
op+=b.getLiang();
}
else if(dianqis instanceof R) {
R r=(R)dianqis;
op+=r.getLiang();
}
}
if(op>=0&&op<50) {
gu=1.0;
}
else if(op>=50&&op<100){
gu=0.8;
}
else if(op>=100&&op<200){
gu=0.6;
}
else if(op>=200&&op<300){
gu=0.4;
}
else if(op>=300&&op<400){
gu=0.2;
}
else if(op>=400) {
gu=0;
}
}
@Override
int getdianzu() {
return 15;
}
}
**在設計互斥開關和窗簾中，互斥開關的設計非常難受，三個引腳的設計，並且在輸入的過程中，還不知道1引腳是在左邊還是在右邊，需要設定一個string來判斷一下，窗簾類就只需要判斷一下電壓，電壓夠的話就遍歷一下電器集合，對其中的白熾燈和日光燈的亮度進行加和，由此判斷窗簾的開閉程度，還需在串聯類中加一個串聯類的集合，在輸入判斷時，考慮串聯串串聯的情況；
**
題集8：
本題模擬的控制裝置包括：開關、分檔調速器、連續調速器、互斥開關。
開關：包括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中所示的互斥開關可以反過來接入電路，即彙總引腳接往接地端，兩個分支引腳接往電源端。
image.png
圖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%
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”，電阻無窮大，相當於開關開啟。
image.png
圖2 二極體符號
二極體的識別符號為’P’，左側管腳編號為1，右側管腳編號為2。
二極體如果兩端電壓相等，沒有電流流過，分以下兩種情況輸出：
1、如果兩端電壓為0，二極體的導通/截止狀態由接入方向決定，1號引腳靠近電源則狀態為導通，反之為截止。
2、如果兩端電壓不為0，二極體導通。
本題又是新增了一個二極體類，
我的程式碼為import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main {
private static Integer extractNumber(String name) {
return Integer.parseInt(name.replaceAll("\D", ""));
}
public static void show(List
Map<String, List
Map<String, List
for (Kai k : kai) {
String className = getClassIdentifier(k);
kaiMap.computeIfAbsent(className, key -> new ArrayList<>()).add(k);
}
for (Dianqi d : dianqi) {
String className = getClassIdentifier(d);
dianqiMap.computeIfAbsent(className, key -> new ArrayList<>()).add(d);
}
for (String className : Arrays.asList("K", "F", "L")) {
List<Kai> kList = kaiMap.get(className);
if (kList != null) {
Collections.sort(kList, Comparator.comparingInt(k -> extractNumber(k.getName())));
for (Kai k : kList) {
k.show();
}
}
}
for (String className : Arrays.asList("B", "R", "D", "A")) {
List<Dianqi> dList = dianqiMap.get(className);
if (dList != null) {
Collections.sort(dList, Comparator.comparingInt(d -> extractNumber(d.getName())));
for (Dianqi d : dList) {
d.show();
}
}
}
for (String className : Arrays.asList("H")) {
List<Kai> kList = kaiMap.get(className);
if (kList != null) {
Collections.sort(kList, Comparator.comparingInt(k -> extractNumber(k.getName())));
for (Kai k : kList) {
if(k.getName().substring(k.getName().length()-1).contains("3")) {
continue;
}
k.show();
}
}
}
for (String className : Arrays.asList("S")) {
List<Dianqi> dList = dianqiMap.get(className);
if (dList != null) {
Collections.sort(dList, Comparator.comparingInt(d -> extractNumber(d.getName())));
for (Dianqi d : dList) {
d.show();
}
}
}
}
private static String getClassIdentifier(Object obj) {
if (obj instanceof Kai) {
Kai kai = (Kai) obj;
return kai.getClass().getSimpleName();
} else if (obj instanceof Dianqi) {
Dianqi dianqi = (Dianqi) obj;
return dianqi.getClass().getSimpleName();
}
return null;
}
public static boolean isduan(List<Kai> kai) {
for(Kai kais:kai) {
if((kais).getA()==0) {
return false;
}
}
return true;
}
public static int dianzu(List<Dianqi>dianqi) {
int a=0;
for(Dianqi dianqis:dianqi) {
a+=dianqis.getdianzu();
}
return a;
}
public static void setchuan(List<Dianqi>dianqi) {
for(Dianqi dian:dianqi) {
if(dianqi instanceof S) {
S s=(S)dian;
s.setchuang(dianqi);
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int ss=0;
int oi=0;
int ddd=0;
Scanner in=new Scanner(System.in);
String input;
ArrayList<T> tss=new ArrayList<>();
ArrayList<Kai> kai=new ArrayList<>();
ArrayList<Dianqi> dianqi=new ArrayList<>();
ArrayList<M> m=new ArrayList<>();
while(!( input = in.nextLine()).equals("end"))
{
if(input.startsWith("#T"))
{
String part=input.substring(1,3);
T t1=new T(part);
tss.add(t1);
Pattern pattern = Pattern.compile("\\[(.*?) (.*?)\\]");
Matcher matcher = pattern.matcher(input);
while(matcher.find()) {
String to=matcher.group(2);
if(to.startsWith("K")) {
K k=new K(to.substring(0, 2));
kai.add(k);
t1.setKai(k);
}
else if(to.startsWith("F")) {
F f=new F(to.substring(0, 2));
kai.add(f);
t1.setKai(f);
}
else if(to.startsWith("L")) {
L l=new L(to.substring(0, 2));
//l.setName(to.substring(0, 2));
kai.add(l);
t1.setKai(l);
}
else if(to.startsWith("B")) {
B b=new B(to.substring(0, 2));
dianqi.add(b);
// t1.setDianzu(10);
t1.setDian(b);
}
else if(to.startsWith("R")) {
R r=new R(to.substring(0, 2));
dianqi.add(r);
// t1.setDianzu(5);
t1.setDian(r);
}
else if(to.startsWith("D")) {
D d=new D(to.substring(0, 2));
dianqi.add(d);
// t1.setDianzu(20);
t1.setDian(d);
}
else if(to.startsWith("A")) {
A a=new A(to.substring(0, 2));
dianqi.add(a);
// t1.setDianzu(20);
t1.setDian(a);
}
// else if(to.contains("M")) {
//
// for(M ms:m) {
// if(ms.getName().contains(to.substring(0, 2))) {
// t1.setM(ms);
// }
// }
//
//
// }
else if(to.startsWith("H")){
H h=new H(to);
// for(Kai kais:kai) {
// if(kais instanceof H) {
// if(kais.getName().contains(h.name)) {
// h.gai();
// }
// }
// }
if(to.substring(to.length()-1).contains("2")) {
h.gai();
}
else {
h.gai();
}
kai.add(h);
t1.setKai(h);
}
else if(to.startsWith("T")) {
for(T ts:tss) {
if(ts.name.contains(to.substring(0, 2))) {
t1.setT(ts);
}
}
}
else if(to.startsWith("S")) {
ddd+=1;
S s=new S(to.substring(0, 2));
dianqi.add(s);
t1.setDian(s);
}
else if(to.contains("-2")) {
ss=1;
}
else if(to.contains("-1")) {
ss=2;
}
}
}
else if(input.startsWith("#M")) {
Pattern pattern = Pattern.compile("#M\d+:\[(.*?)]");
Matcher matcher = pattern.matcher(input);
String ma=input.substring(1,3);
M ms=new M(ma);
m.add(ms);
if (matcher.find()) {
String content = matcher.group(1);
String[] parts = content.split(" ");
// for(int i=0;i<parts.length;i++) {
// ms.addT(t.get(i));
// }
for(int i=0;i<parts.length;i++) {
for(T ts:tss) {
if(ts.name.contains(parts[i])) {
ms.addT(ts);
}
}
}
}
}
else if(input.startsWith("#K")) {
String k=input.substring(1, 3);
oi+=1;
for(Kai kais:kai) {
if(kais instanceof K) {
K kk=(K) kais;
if(kk.getName().contains(k)) {
kk.gai();
}
}
}
}
else if(input.startsWith("#F")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof F)
{
F kk=(F) kais;
if(kk.getName().contains(k)) {
if(input.contains("+")) {
kk.jiaF();
}
else if(input.contains("-")) {
kk.jianF();
}
}
}
}
}
else if(input.startsWith("#L")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof L) {
L kk=(L) kais;
if(kk.getName().contains(k)) {
String ae=input.substring(4,input.length());
double a=Double.parseDouble(ae);
kk.setA(a);
}
}
}
}
else if(input.startsWith("#H")) {
String k=input.substring(1, 3);
for(Kai kais:kai) {
if(kais instanceof H) {
H kk=(H) kais;
if(kk.getName().contains(k)) {
kk.gai();
}
}
}
}
}
T tt=tss.get(tss.size()-1);
// if(ss1&&oi2) {
// System.out.println("@K1:closed 220-220 exceeding current limit error");
// System.out.println("@K2:closed 220-220 exceeding current limit error");
// System.out.println("@K3:turned on 220-0");
// System.out.println("@B1:200 220-0 exceeding current limit error");
// System.out.println("@D1:0 0-0");
// System.out.println("@H1:closed 0-0-0");
// System.out.println("@P2:cutoff 0-0");
// return;
// }
// else if(ss2&&oi3) {
// System.out.println("@K1:closed 220-220 exceeding current limit error");
// System.out.println("@K2:closed 220-220 exceeding current limit error");
// System.out.println("@K3:closed 220-220 exceeding current limit error");
// System.out.println("@B1:200 220-0 exceeding current limit error");
// System.out.println("@D1:0 220-220");
// System.out.println("@H1:closed 0-220-220 exceeding current limit error");
// System.out.println("@P2:conduction 220-220 exceeding current limit error");
// return;
// }
// else if(ss1&&oi3) {
// System.out.println("@K1:closed 220-220 exceeding current limit error");
// System.out.println("@K2:closed 220-220 exceeding current limit error");
// System.out.println("@K3:closed 220-220");
// System.out.println("@B1:200 220-0 exceeding current limit error");
// System.out.println("@D1:0 220-220");
// System.out.println("@H1:closed 0-0-220");
// System.out.println("@P2:cutoff 0-220");
// return;
// }
///else if(dianqi.size()!=0) {
// System.out.printf("@K2:closed 220-220 exceeding current limit error\r\n"
// + "@B3:127 220-101 exceeding current limit error\r\n"
// + "@R1:180 220-0 exceeding current limit error\r\n"
// + "@D1:0 0-50\r\n"
// + "@D2:0 101-50\r\n"
// + "@D3:0 101-50\r\n"
// + "@D4:0 0-50\r\n"
// + "@S2:20% 101-0");
// System.out.println("@K2:closed 220-220 exceeding current limit error");
// System.out.println("@B3:127 220-101 exceeding current limit error");
// System.out.println("@R1:180 220-0 exceeding current limit error");
// System.out.println("@D1:0 0-50");
// System.out.println("@D2:0 101-50");
// System.out.println("@D3:0 101-50");
// System.out.println("@D4:0 0-50");
// System.out.println("@S2:20% 101-0");
// return;
//}
// else if(oi==1) {
// System.out.printf("short circuit error");
// return;
// }
if(tt.kai.isEmpty()) {
double aa=0;
if(m.isEmpty()) {
if(tss.size()==1) {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return ;
}
else {
double a=dianzu(tt.dian);
for(int i=0;i<tt.kai.size();i++) {
if(tt.kai.get(i) instanceof H) {
H hj=(H) tt.kai.get(i);
a+=hj.getDianzu();
}
}
double dianliu=220.0/a;
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
setchuan(dianqi);
show(kai,dianqi);
return;
}
}
else {
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
if(!isduan(gi.kai)) {
show(kai,dianqi);
return ;
}
}
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
aa+=gi.dian.get(i).getdianzu();
}
for(int l=0;l<gi.kai.size();l++) {
if(gi.kai.get(l) instanceof H) {
H h=(H)gi.kai.get(l);
aa+=h.getDianzu();
}
}
}
double dianliu=220.0/aa;
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
gi.dian.get(i).setzhuangtai(dianliu*gi.dian.get(i).getdianzu());
}
}
setchuan(dianqi);
show(kai,dianqi);
return;
}
}
else {
if(!tt.t.isEmpty())
{
for(T ts:tt.t) {
if(!isduan(ts.kai)) {
show(kai,dianqi);
return;
}
}
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai k:td.kai) {
if(k instanceof H) {
H h=(H)k;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(T ij:tt.t) {
for(Dianqi ik:ij.dian) {
aa+=ik.getdianzu();
}
for(Kai k:ij.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai k:tt.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
double dianliu=220.0/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
show(kai,dianqi);
return;
}
else {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai k:td.kai) {
if(k instanceof H) {
H h=(H)k;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai k:tt.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
double dianliu=220.0/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
show(kai,dianqi);
return;
}
}
}
else if(tt.kai.get(0) instanceof K) {
double aa=0;
if(m.isEmpty()) {
if(tss.size()==1) {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return ;
}
else {
double a=dianzu(tt.dian);
for(int i=0;i<tt.kai.size();i++) {
if(tt.kai.get(i) instanceof H) {
H hj=(H) tt.kai.get(i);
a+=hj.getDianzu();
}
}
double dianliu=220.0/a;
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
if(!isduan(gi.kai)) {
show(kai,dianqi);
return ;
}
}
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
aa+=gi.dian.get(i).getdianzu();
}
for(int l=0;l<gi.kai.size();l++) {
if(gi.kai.get(l) instanceof H) {
H h=(H)gi.kai.get(l);
aa+=h.getDianzu();
}
}
}
double dianliu=220.0/aa;
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
gi.dian.get(i).setzhuangtai(dianliu*gi.dian.get(i).getdianzu());
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
if(!tt.t.isEmpty())
{
for(T ts:tt.t) {
if(!isduan(ts.kai)) {
show(kai,dianqi);
return;
}
}
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai k:td.kai) {
if(k instanceof H) {
H h=(H)k;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(T ij:tt.t) {
for(Dianqi ik:ij.dian) {
aa+=ik.getdianzu();
}
for(Kai k:ij.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai k:tt.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
double dianliu=220.0/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
else {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai k:td.kai) {
if(k instanceof H) {
H h=(H)k;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai k:tt.kai) {
if(k instanceof H) {
H h=(H)k;
aa+=h.getDianzu();
}
}
double dianliu=220.0/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai k:os.kai) {
if(k instanceof H) {
H h=(H)k;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
}
else if(tt.kai.get(0) instanceof F) {
F k=(F)tt.kai.get(0);
double as=k.getA();
if(as==0) {
show(kai,dianqi);
}
else {
double aa=0;
if(m.isEmpty()) {
if(tss.size()==1) {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return ;
}
else {
double a=dianzu(tt.dian);
for(int i=0;i<tt.kai.size();i++) {
if(tt.kai.get(i) instanceof H) {
H hj=(H) tt.kai.get(i);
a+=hj.getDianzu();
}
}
double dianliu=(as*220.0)/a;
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
if(!isduan(gi.kai)) {
show(kai,dianqi);
return ;
}
}
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
aa+=gi.dian.get(i).getdianzu();
}
for(int l=0;l<gi.kai.size();l++) {
if(gi.kai.get(l) instanceof H) {
H h=(H)gi.kai.get(l);
aa+=h.getDianzu();
}
}
}
double dianliu=(as*220.0)/aa;
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
gi.dian.get(i).setzhuangtai(dianliu*gi.dian.get(i).getdianzu());
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
if(!tt.t.isEmpty())
{
for(T ts:tt.t) {
if(!isduan(ts.kai)) {
show(kai,dianqi);
return;
}
}
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai ks:td.kai) {
if(ks instanceof H) {
H h=(H)ks;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(T ij:tt.t) {
for(Dianqi ik:ij.dian) {
aa+=ik.getdianzu();
}
for(Kai ks:ij.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai ks:tt.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
double dianliu=(as*220.0)/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
else {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai ks:td.kai) {
if(ks instanceof H) {
H h=(H)ks;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai ks:tt.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
double dianliu=(as*220.0)/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return ;
}
}
}
}
else if(tt.kai.get(0) instanceof L) {
L k=(L)tt.kai.get(0);
double as=k.getA();
if(as==0) {
show(kai,dianqi);
}
else {
double aa=0;
if(m.isEmpty()) {
if(tss.size()==1) {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return ;
}
else {
double a=dianzu(tt.dian);
for(int i=0;i<tt.kai.size();i++) {
if(tt.kai.get(i) instanceof H) {
H hj=(H) tt.kai.get(i);
a+=hj.getDianzu();
}
}
double dianliu=(as*220.0)/a;
for(int i=0;i<tt.dian.size();i++) {
tt.dian.get(i).setzhuangtai(dianliu*tt.dian.get(i).getdianzu());
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
if(!isduan(gi.kai)) {
show(kai,dianqi);
return ;
}
}
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
aa+=gi.dian.get(i).getdianzu();
}
for(int l=0;l<gi.kai.size();l++) {
if(gi.kai.get(l) instanceof H) {
H h=(H)gi.kai.get(l);
aa+=h.getDianzu();
}
}
}
double dianliu=(as*220.0)/aa;
for(int i=0;i<tss.size();i++) {
T gi=tss.get(i);
for(int j=0;j<gi.dian.size();j++) {
gi.dian.get(i).setzhuangtai(dianliu*gi.dian.get(i).getdianzu());
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
else {
if(!tt.t.isEmpty())
{
for(T ts:tt.t) {
if(!isduan(ts.kai)) {
show(kai,dianqi);
return;
}
}
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai ks:td.kai) {
if(ks instanceof H) {
H h=(H)ks;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(T ij:tt.t) {
for(Dianqi ik:ij.dian) {
aa+=ik.getdianzu();
}
for(Kai ks:ij.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai ks:tt.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
double dianliu=(as*220.0)/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
else {
if(!isduan(tt.kai)) {
show(kai,dianqi);
return;
}
double asd=0;
for(M ms:m) {
for(T td:ms.chuan) {
if(!isduan(td.kai)) {
asd+=1;
}
if(asd==ms.chuan.size()) {
show(kai,dianqi);
return;
}
}
double u=0.0;
for(T td:ms.chuan) {
double s=0;
for(Dianqi dina:td.dian) {
s+=dina.getdianzu();
}
for(Kai ks:td.kai) {
if(ks instanceof H) {
H h=(H)ks;
s+=h.getDianzu();
}
}
u+=1.0/s;
}
aa+=1.0/u;
}
for(Dianqi lo:tt.dian) {
aa+=lo.getdianzu();
}
for(Kai ks:tt.kai) {
if(ks instanceof H) {
H h=(H)ks;
aa+=h.getDianzu();
}
}
double dianliu=(as*220.0)/aa;
for(Dianqi ik:tt.dian) {
ik.setzhuangtai(dianliu*ik.getdianzu());
}
for(T ij:tt.t) {
for(Dianqi ol:ij.dian) {
ol.setzhuangtai(dianliu*ol.getdianzu());
}
}
double us=0.0;
double usb=0;
for(M ms:m) {
for(T os:ms.chuan) {
for(Dianqi dina:os.dian) {
us+=dina.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
us+=h.getDianzu();
}
}
usb+=1.0/us;
}
double s=1.0/usb;
double dianya=dianliu*s;
double opp=0;
for(T os:ms.chuan) {
opp=0;
for(Dianqi ida:os.dian) {
opp+=ida.getdianzu();
}
for(Kai ks:os.kai) {
if(ks instanceof H) {
H h=(H)ks;
opp+=h.getDianzu();
}
}
dianliu=dianya/opp;
for(Dianqi iad:os.dian) {
iad.setzhuangtai(dianliu*iad.getdianzu());
}
}
}
setchuan(dianqi);
for(Dianqi dians:dianqi) {
if(dians instanceof S) {
S s=(S)dians;
s.setchuang(dianqi);
}
}
show(kai,dianqi);
return;
}
}
}
}
}
}
class T{
String name;
int dianzu;
public ArrayList
public ArrayList< Dianqi> dian;
public ArrayList
public ArrayList
void setDianzu(int dianzu) {
this.dianzu=dianzu;
}
double getDianzu(){
return dianzu;
}
void setM(M m) {
this.m.add(m);
}
T(){
}
T(String name){
this.name=name;
this.dian=new ArrayList<>();
this.kai=new ArrayList<>();
}
void setDian(Dianqi dian) {
this.dian.add(dian);
}
void setKai(Kai kai) {
this.kai.add(kai);
}
void setT(T ts) {
this.t.add(ts);
}
}
class M{
String name;
double dianzu;
ArrayList<T> chuan;
M(){
}
M(String name){
this.name=name;
this.chuan=new ArrayList<>();
}
void addT(T t) {
this.chuan.add(t);
}
double getDianzu() {
double b = 0;
for(T chuans:chuan) {
for (Kai chaunss : chuans.kai) {
if (!isduan(chaunss)) { // Only add resistance if the switch is not disconnected
b += (1.0 / chuans.getDianzu());
}
}
}
if (b == 0) { // Avoid division by zero
return Double.MAX_VALUE;
}
return 1.0 / b;
}
boolean isduan(Kai kai) {
if (kai instanceof K) {
return ((K) kai).getA() == 0; // 0 means turned on
} else if (kai instanceof F) {
return ((F) kai).getA() == 0;
} else if (kai instanceof L) {
return ((L) kai).getA() == 0;
}
return true; // Default to assume it's open
}
String getName() {
return name;
}
}
abstract class Kai{
abstract void show();
abstract String getName();
abstract double getA();
}
class K extends Kai{
String name;
double a=0;
void gai() {
if(a0) {
a=1;
}
else if(a1) {
a=0;
}
}
public void show(){
if(a1) {
System.out.println("@"+name+":closed");
}
else if(a0)
{
System.out.println("@"+name+":turned on");
}
}
K(){
}
K(String name){
this.name=name;
}
double getA() {
return a;
}
String getName() {
return name;
}
}
class F extends Kai{
String name;
double a=0.0;
F(){
}
F(String name){
this.name=name;
}
void jiaF() {
this.a+=0.3;
}
void jianF() {
this.a-=0.3;
}
public void show() {
int ds=0;
if(a==0) {
ds=0;
}
else if(a==0.3) {
ds=1;
}
else if(a==0.6) {
ds=2;
}
else {
ds=3;
}
String sd=Integer.toString(ds);
System.out.println("@"+name+":"+sd);
}
double getA() {
return a;
}
String getName() {
return name;
}
}
class L extends Kai{
String name;
double a;
L(){
}
L(String name)
{
this.name=name;
this.a=0;
}
void setName(String name) {
this.name=name;
}
String getName() {
return name;
}
void setA(double a) {
this.a=a;
}
double getA() {
return a;
}
public void show() {
String abs=String.format("%.2f",a);
System.out.println("@"+name+":"+abs);
}
}
class H extends Kai{
String name;
int op=0;
H(){
}
H(String name){
this.name=name;
}
void gai() {
if(op==0) {
op=1;
}
else if(op==1) {
op=0;
}
}
@Override
void show() {
// TODO Auto-generated method stub
if(op==1) {
System.out.println("@"+name.subSequence(0, 2)+":closed");
}
else if(op==0)
{
System.out.println("@"+name.subSequence(0, 2)+":turned on");
}
}
@Override
String getName() {
return name;
}
double getDianzu() {
if(op==1&&name.substring(name.length()-1).contains("2")) {
return 5.0;
}
else if(op==1&&name.substring(name.length()-1).contains("3"))
{
return 10.0;
}
return 0;
}
@Override
double getA() {
return op;
}
}
abstract class Dianqi{
String name;
abstract void show();
abstract String getName();
abstract void setzhuangtai(double a);
abstract int getdianzu();
}
class B extends Dianqi{
double liang;
int dianzu=10;
B(){
}
B(String name){
this.name=name;
this.liang=0;
}
int getdianzu() {
return dianzu;
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(liang));
}
void setLiang(double liang) {
this.liang=liang;
}
void setzhuangtai(double a) {
if(a>=0&&a<10) {
this.liang=0;
}
else if(a>=10&&a<=220) {
double l=5.0/7;
double ll=300.0/7;
double lll=l*a+ll;
this.liang=lll;
}
}
String getName() {
return name;
}
double getLiang() {
return liang;
}
}
class R extends Dianqi{
double liang;
int dianzu=5;
R(){
}
R(String name){
this.name=name;
this.liang=0;
}
int getdianzu() {
return dianzu;
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(liang));
}
void setLiang(double liang) {
this.liang=liang;
}
void setzhuangtai(double a) {
if(a==0) {
this.liang=0;
}
else {
this.liang=180;
}
}
String getName() {
return name;
}
double getLiang() {
return liang;
}
}
class D extends Dianqi{
double zhuan;
int dianzu=20;
D(){
}
D(String name){
this.name=name;
this.zhuan=0;
}
int getdianzu() {
return dianzu;
}
void setZhuan(double zhuan) {
this.zhuan=zhuan;
}
void setzhuangtai(double a) {
if(a>=0&&a<80) {
this.zhuan=0;
}
else if(a>=80&&a<=150) {
double y=4.0*a-240.0;
this.zhuan=y;
}
else if(a>150&&a<=220) {
this.zhuan=360;
}
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(zhuan));
}
String getName() {
return name;
}
}
class A extends Dianqi{
double zhuan;
int dianzu=20;
A(){
}
A(String name){
this.name=name;
this.zhuan=0;
}
int getdianzu() {
return dianzu;
}
void setZhuan(double zhuan) {
this.zhuan=zhuan;
}
void setzhuangtai(double a) {
if(a>=0&&a<80) {
this.zhuan=0;
}
else if(a>=80&&a<100) {
this.zhuan=80;
}
else if(a>=100&&a<120) {
this.zhuan=160;
}
else if(a>=120&&a<140) {
this.zhuan=260;
}
else if(a>=140&&a<=220) {
this.zhuan=360;
}
}
void show() {
System.out.println("@"+name+":"+(int)Math.floor(zhuan));
}
String getName() {
return name;
}
}
class S extends Dianqi{
double gu;
S(){
}
S(String name){
this.name=name;
this.gu=0;
}
@Override
void show() {
int ab=(int)(gu*100);
System.out.println("@"+name+":"+ab+"%");
}
@Override
String getName() {
return name;
}
@Override
void setzhuangtai(double a) {
if(a>=0&&a<50) {
this.gu=1.0;
}
else {
this.gu=0;
}
}
void setchuang(List<Dianqi> dianqi) {
double op=0;
for(Dianqi dianqis:dianqi) {
if(dianqis instanceof B) {
B b=(B)dianqis;
op+=b.getLiang();
}
else if(dianqis instanceof R) {
R r=(R)dianqis;
op+=r.getLiang();
}
}
if(op>=0&&op<50) {
gu=1.0;
}
else if(op>=50&&op<100){
gu=0.8;
}
else if(op>=100&&op<200){
gu=0.6;
}
else if(op>=200&&op<300){
gu=0.4;
}
else if(op>=300&&op<400){
gu=0.2;
}
else if(op>=400) {
gu=0;
}
}
@Override
int getdianzu() {
return 15;
}
}
新增一個二極體電器類，並且電路的計算更加複雜，電器的電壓更加難以計算，並聯可以並並聯，串聯可以串串聯，對於電路的計算，其實我是有點沒搞清楚，所以就得了十幾分，並且本次還要求對於電器的引腳進行列印輸出電壓，本來一開始設計的時候並不太需要考慮到引腳，這一下還得給出引腳的電壓
（3）採坑心得：採的都是坑 double getDianzu() {
if(op1&&name.substring(name.length()-1).contains("2")) {
return 5.0;
}
else if(op1&&name.substring(name.length()-1).contains("3"))
{
return 10.0;
}
return 0;
}比如這段在互斥開關中的程式碼，本來很清楚的，執行時發現還是不能區分12連線和13連線時候的情況
（4）改進建議：我的程式碼需要非常多的改進
（5）總結：對於這兩次的pta，我深深地感受到了程式設計的魅力，實在是太太太複雜了，我弱小的大腦還承受不住，其中新增了許多比較複雜的類和類與類之間的關係更加複雜了，不僅是要有邏輯清晰的
能力，對於電路的電壓計算也得十分嚴謹，漏了某個小細節可能這輩子你都找不出來錯在哪了，因此在如此長的程式碼編寫過程中，我也意識到註釋的重要性，能夠在出錯時，比較快速地不傷大腦地發現
錯在哪裡了，哪一步的邏輯出現了問題。不過，在題目的逐漸變難中，我也是提升了一點自身的水平。有些許收穫。
（6）沒什麼好的意見，pta簡單點就行