牛客網 NOIP/CSP 真題班

15.1 普及組5-字符串處理

第4節 立體圖

 小淵是個聰明的孩子，他經常會給周圍的小朋友們講些自己認爲有趣的內容。最近，他準備給小朋友們講解立體圖，請你幫他畫出立體圖。
小淵有一塊麪積爲m*n的矩形區域，上面有m*n個邊長爲1的格子，每個格子上堆了一些同樣大小的吉姆（積木的長寬高都是1），小淵想請你打印出這些格子的立體圖。我們定義每個積木爲如下格式，並且不會做任何翻轉旋轉，只會嚴格以這一種形式擺放：

每個頂點用1個加號’+’表示，長用3個”-“表示，寬用1個”/”表示，高用兩個”|”表示。字符’+’，‘-‘，’/’，‘|’的ASCII碼分別爲43，45，47，124。字符’.’（ASCII碼46）需要作爲背景輸出，即立體圖裏的空白部分需要用’.’代替。立體圖的畫法如下面的規則：

若兩塊積木左右相鄰      若兩塊積木上下相鄰       若兩塊積木前後相鄰
圖示爲：                圖示爲：                 圖示爲：

                    

立體圖中，定義位於第(m,1)的格子（即第m行第1列的格子）上面自底向上的第一塊積木（即最下面的一塊積木）的左下角頂點爲整張圖最左下角的點。

 

輸入描述:

第一行有用空格隔開的兩個整數m和n，表示有m*n個格子（1 ≤ m，n ≤ 50）。
接下來的m行，是一個m*n的矩陣，每行有n個用空格隔開的整數，其中第i行第j列上的整數表示第i行第j列的格子上摞有多少個積木（1 ≤ 每個格子上的積木 ≤ 100）。

 

輸出描述:

題目要求的立體圖，是一個K行L列的字符矩陣，其中K和L表示最少需要K行L列才能按規定輸出立體圖。

示例1

輸入

3 4
2 2 1 2
2 2 1 1
3 2 1 2

輸出

......+---+---+...+---+
..+---+  /   /|../   /|
./   /|-+---+ |.+---+ |
+---+ |/   /| +-|   | +
|   | +---+ |/+---+ |/|
|   |/   /| +/   /|-+ |
+---+---+ |/+---+ |/| +
|   |   | +-|   | + |/.
|   |   |/  |   |/| +..
+---+---+---+---+ |/...
|   |   |   |   | +....
|   |   |   |   |/.....
+---+---+---+---+......

乍一看很噁心，但是實際考察內容並不難的嚇人題。

解題：對於立體圖形，很重要的一點就是建立座標系。首先觀察題中所給的三個基本圖形（左右，上下，前後相鄰），可以看出，右邊的覆蓋左邊的，上面的覆蓋下面的，前面的覆蓋後面的，於是我們可以按照下圖方式進行建系：

於是覆蓋規則變爲，Y值大的覆蓋Y值小的（右邊覆蓋左邊），Z值大的覆蓋Z值小的（上面覆蓋下面），X值大的覆蓋X值小的（前面覆蓋後面)。可知在我們想從立體圖映射到平面圖的時候必須按照X、Y、Z各自從大到小的順序進行覆蓋，X、Y、Z之間的順序無影響。問題簡化爲，已經立體方塊的擺放，根據題意確定映射規則，在平面圖中繪出該圖形。爲方便構圖，我們需要設立一個定點，並且將圖紙設置的足夠大。題解中，我們設圖紙爲500*500，（題解中聲明經驗算，圖形最大不會超過400*400，保險起見設置了500*500），並以整體圖形的最底最左最前的方塊爲基準點。

題面中給的是m*n的高度爲g[i][j]的方塊擺放數據圖，抽象出每一個方塊的數據表示爲(x,y,z)，表示該方塊處在X方向上第x層，Y方向上第y層，Z方向上第z層的方塊。現在需要一個映射規則將其放置到平面圖上，我們取方塊的左下前方塊爲每一個方塊映射的基準點進行映射，取此點對於x和y的座標都比較容易確立，映射完之後我們就把寫好的box塗上去即可。

                    

我們根據三個基本圖來確立映射點的座標：

A.Y座標變化不會改變X和Z座標

B.Z座標變化會導致X座標變化，設Z變化了Δ，則X變化量爲-3*Δ。（3是直接數第二個圖兩個立方體x座標的差得到）

C.X座標變化會導致Y座標變化，設Z變化了Δ，則Y變化量爲+4*Δ。（4是直接數第二個圖兩個立方體y座標的差得到）

增量正負號的確立是由於我們是按照X從小到大，Z從小到達的順序進行放置的，第二個圖中上面的立方體後放，第三個圖中前面的立方體後放。

所有變化的基準方塊爲（499，0，0）處的方塊，在放置時記得更新當前能到到達的上邊界和右邊界（左邊界天然固定爲0，下邊界根據該算法直接固定在圖紙的底面）。

剩餘最後一個問題就是如何塗這個box，我們直接將左下角的點通過(x-5,y-0)對應到整個box的開始點(0,0)，然後遇到box的點不爲'.'即爲有用數據的時候進行填塗即可。

#include<iostream>
using namespace std;

char box[6][8]={
    "..+---+",
    "./   /|",
    "+---+ |",
    "|   | +",
    "|   |/.",
    "+---+..",
};//一個立方體在平面中的投影

//本題採取對立方塊進行定位的操作  (x,y,z)表示 x方向第x層 y方向第y層 z方向第z層 取方塊的左下前的點爲定位點
//由題目中三個基本圖形可以看出 在立體圖中改變x會導致投影到[x,y]面的座標x和y的改變，改變y則只改變投影座標的y，改變z則只改變投影座標的z
const int N=500;
int n,m;
char ch[N][N];
int g[N][N];

int main(){
    cin>>n>>m;
    int i,j,x,y,z,X,Y,up=N,right=0;
    
    for(i=0;i<n;++i){
        for(j=0;j<m;++j){
            cin>>g[i][j];
        }
    }
    
    for(i=0;i<N;++i){
        for(j=0;j<N;++j){
            ch[i][j]='.';
        }
    }
    
    for(x=0;x<n;++x){
        for(y=0;y<m;++y){
            for(z=0;z<g[x][y];++z){
                
                X=499-(n-1-x)*2-3*z;
                Y=4*y+(n-1-x)*2;
                
                up=min(up,X-5);//獲得實際填入二維平面的圖形的上邊界
                right=max(right,Y+6);//獲得實際填入二維平面的圖形的右邊界
                //獲得投影點
                for(i=0;i<6;++i){
                    for(j=0;j<7;++j){
                        if(box[i][j]!='.'){
                            ch[X-5+i][Y+j]=box[i][j];
                        }
                    }
                }
            }
        }
    }
    
    for(i=up;i<N;++i){
        for(j=0;j<=right;++j)
            cout<<ch[i][j];
        cout<<endl;
    }
    
}

•  

17.1 普及組7-數學

第2節 麥森數

形如2P-1的素數稱爲麥森數，這時P一定也是個素數。但反過來不一定，即如果P是個素數，2P-1不一定也是素數。到1998年底，人們已找到了37個麥森數。最大的一個是P=3021377，它有909526位。麥森數有許多重要應用，它與完全數密切相關。

任務：輸入P（1000<P<3100000），計算2P-1的位數和最後500位數字（用十進制高精度數表示）

輸入描述:

只包含一個整數P（1000<P<3100000)

輸出描述:

第一行：十進制高精度數2P-1的位數。

第2-11行：十進制高精度數2P-1的最後500位數字。（每行輸出50位，共輸出10行，不足500位時高位補0）

不必驗證2P-1與P是否爲素數。

示例1

輸入

1279

輸出

386
00000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000
00000000000000104079321946643990819252403273640855
38615262247266704805319112350403608059673360298012
23944173232418484242161395428100779138356624832346
49081399066056773207629241295093892203457731833496
61583550472959420547689811211693677147548478866962
50138443826029173234888531116082853841658502825560
46662248318909188018470682222031405210266984354887
32958028878050869736186900714720710555703168729087

嚇人題再次石錘->->，首先來看第一問，求位數，實際上就是求log10(2^p-1)+1，首先p的範圍最大可以到300w，乍一看無法計算，但是2的次冪有個特點就是末位只有2、4、8、6四種情況，用他們減去1並不會有借位發生，即2^p與2^p-1的位數是相同的，於是答案變爲log10(2^p)+1，利用對數運算的性質變爲plog10(2)+1。

第二問就是一個高精度計算罷了，學習一波人家的高精度：由於要求最後500位，利用快速冪的複雜度變爲500*500*log2(p)。

#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;

const int N=510;

int res[N],a[N],c[N];

void mul(int res[],int a[],int b[]){
    int i,j;
    memset(c,0,sizeof(c));
    for(i=0;i<N;++i){
        for(j=0;i+j<N&&j<N;++j){
            c[i+j]+=a[i]*b[j];
        }
    }
    for(i=0,j=0;i<N;++i){ //處理進位
        j+=c[i];
        res[i]=j%10;
        j/=10;
    }
}

void qmi(int p){
    res[0]=1;
    a[0]=2;
    while(p){ 
        if(p&1)mul(res,res,a);   //res=res*a;
        mul(a,a,a);  //a=a*a;
        p>>=1;
    }
}

int main(){
    int p,i,j;
    cin>>p;
    cout<<(int)(p*log10(2))+1<<endl;
    qmi(p);
    --res[0];
    for(j=499;j>=0;j--){
        cout<<res[j];
        if(j%50==0)cout<<endl;
    }
    return 0;
}

•  

第1章 7月22日提高組1-模擬

第2節 時間複雜度

給出了他自己算出的時間複雜度，可他的編程老師實在不想一個一個檢查小明的程序，於是你的機會來啦！下面請你編寫程序來判斷小明對他的每個程序給出的時間複雜度是否正確。 A++ 語言的循環結構如下：
F i x y
循環體
E
然後判斷 i 和 y 的大小關係，若 i 小於等於 y 則進入循環，否則不進入。每次循環結束後i都會被修改成 i +1，一旦 i 大於 y 終止循環。 x 和 y 可以是正整數（x 和 y 的大小關係不定）或變量 n。n 是一個表示數據規模的變量，在時間複雜度計算中需保留該變量而不能將其視爲常數，該數遠大於 100。 `E`表示循環體結束。循環體結束時，這個循環體新建的變量也被銷燬。
注：本題中爲了書寫方便，在描述複雜度時，使用大寫英文字母 O 表示通常意義下  的概念。

輸入描述:

輸入文件第一行一個正整數 t，表示有 t(t≤ 10) 個程序需要計算時間複雜度。
每個程序我們只需抽取其中 `F i x y`和`E`即可計算時間複雜度。注意：循環結構允許嵌套。 
接下來每個程序的第一行包含一個正整數 L 和一個字符串，L 代表程序行數，字符串表示這個程序的複雜度，`O(1)`表示常數複雜度，`O(n^w)` 表示複雜度爲 nw，其中 w 是一個小於 100 的正整數（輸入中不包含引號），輸入保證複雜度只有 `O(1)` 和 `O(n^w)` 兩種類型。 
接下來 L 行代表程序中循環結構中的 `F i x y` 或者 `E`。 程序行若以 `F` 開頭，表示進入一個循環，之後有空格分離的三個字符（串）`i x y`，其中 i 是一個小寫字母（保證不爲 `n` ），表示新建的變量名，x 和 y 可能是正整數或 `n` ，已知若爲正整數則一定小於 100。  程序行若以 `E`開頭，則表示循環體結束。

輸出描述:

輸出文件共 t 行，對應輸入的 t 個程序，每行輸出`Yes`或`No`或者`ERR`，若程序實際複雜度與輸入給出的複雜度一致則輸出 `Yes`，不一致則輸出`No`，若程序有語法錯誤（其中語法錯誤只有: ①F 和 E 不匹配 ②新建的變量與已經存在但未被銷燬的變量重複兩種情況），則輸出`ERR`。
注意：即使在程序不會執行的循環體中出現了語法錯誤也會編譯錯誤，要輸出`ERR`。

示例1

輸入

8
2 O(1)
F i 1 1
E
2 O(n^1)
F x 1 n
E
1 O(1)
F x 1 n
4 O(n^2)
F x 5 n
F y 10 n
E
E
4 O(n^2)
F x 9 n
E
F y 2 n
E
4 O(n^1)
F x 9 n
F y n 4
E
E
4 O(1)
F y n 4
F x 9 n
E
E
4 O(n^2)
F x 1 n
F x 1 10
E
E

輸出

Yes
Yes
ERR
Yes
No
Yes
Yes
ERR

說明

第一個程序 i 從1 到 1 是常數複雜度。
第二個程序 x 從 1 到 n 是 n 的一次方的複雜度。
第三個程序有一個 `F` 開啓循環卻沒有E結束，語法錯誤。
第四個程序二重循環，n 的平方的複雜度。
第五個程序兩個一重循環，n 的一次方的複雜度。
第六個程序第一重循環正常，但第二重循環開始即終止（因爲 n 遠大於 100，100 大於 4）。
第七個程序第一重循環無法進入，故爲常數複雜度。
第八個程序第二重循環中的變量 x 與第一重循環中的變量重複，出現語法錯誤②，輸出 `ERR`。

 

備註:

對於 30% 的數據：不存在語法錯誤，數據保證小明給出的每個程序的前 L/2 行一定爲以 `F` 開頭的語句，第 L/2+1 行至第 L 行一定爲以 `E` 開頭的語句，L≤ 10，若 x,y 均爲整數，x 一定小於 y，且只有 y 有可能爲 `n`。
對於 50% 的數據：不存在語法錯誤，L≤ 100，且若 x,y 均爲整數，x 一定小於 y，且只有 y 有可能爲 `n`。
對於 70% 的數據：不存在語法錯誤，L≤ 100。
對於 100% 的數據：t≤ 10,L≤ 100。若 x,y 均爲整數，x 一定小於 y，且只有 y 有可能爲 `n`。

首先對於循環結構，For和End的匹配，自然可以藉助括號匹配的方法，用棧結構，剩下需要的就是計算最高次的複雜度。

對於循環結構，我們知道：

A.如果當前層不能執行，那麼嵌套在它之內的所有層都不能正常執行。

B.每嵌套一層可以正常執行的層，時間複雜度就會變爲外層的所有複雜度×當前層的運算複雜度。

爲了方便表示，我們用n^x次方中的x表示每層的複雜度，這樣計算總體複雜度的時候，只需要對x進行加減運算即可。

另外，爲了實現對變量名的探測，而這題規定了變量名只會是小寫字母，我們開一個30大小的bool數組用於標記出現情況。

具體算法，首先初始化一個棧，結構爲pair<char,int>型，用於表示當前層的變量以及當前程序運行到當前層時能到達的複雜度的指數。

對每一個For做如下操作：

1.如果變量名發生衝突，則程序發生錯誤，後續只需要將該次的輸入數據讀空而不進行任何操作

2.否則計算當前層的運算量：

如果當前層是可執行層，如果棧頂層也可以執行，將本層的指數加上棧頂元素的複雜度指數作爲程序運行到當前層能到達的複雜度，將當前層壓入棧。如果棧頂層不可執行，表示當前層是嵌套在一個不可執行的層裏的，應該將當前層設置爲不可執行，將當前層壓入棧。我們用複雜度指數爲-1表示不可執行。

如果當前層不可執行（x>y)，那麼壓入棧。

最後記得更新一下最大的複雜度指數並把所使用的變量進行標記。

對每一個End做如下操作：

1.如果需要彈棧時棧空，發生錯誤，後續只讀不操作。

2.否則從棧中彈出元素，並把變量名標記爲可用。

#include<iostream>
#include<string>
#include<cstring>
#include<sstream>
using namespace std;
typedef pair<char,int> Time;   //局部變量名  截至目前層的時間複雜度

const int N=110;

bool exist[30];
Time stack[N];  //棧結構
int tt;   //棧頂指針，爲便於程序涉及，數組角標爲0之處表示複雜度爲n^0，表示循環所在的程序執行一次 

int string_to_number(string str){
    int i,n=str.length(),ans=0;
    for(i=0;i<n;++i){
        ans=ans*10+str[i]-'0';
    }
    return ans;
}

int get_time(string str){  //計算給出的複雜度
    if(str=="O(1)")return 0;
    int t=str.find("^");
    string number=str.substr(t+1);
    number.pop_back();
    return string_to_number(number);
}

int compute_time(string x,string y){  // 計算當前層的運算量 
    if(x=="n"){
        if(y=="n") return 0;
        return -1;
    }
    if(y=="n"){
        return 1;
    }
    int a=string_to_number(x),b=string_to_number(y);
    if(a<=b)return 0;
    return -1;
}

int main(){
    int T,n,O,maxTime,time;
    bool error;
    string str,F,i,x,y;
    cin>>T;
    while(T--){
        cin>>n>>str;  //語句和複雜度
        O=get_time(str);
        
        getline(cin,str);//讀掉多餘的換行
        
        maxTime=0,error=false,tt=0;
        memset(exist,false,sizeof(exist));
        
        while(n--){
            getline(cin,str);
            
            if(error)continue;//有錯誤發生 直接讀取但不操作
            
            if(str=="E"){
                if(!tt){ //棧空還要彈 顯然語法錯誤 
                	//cout<<"循環bug"<<endl;
                	error=true;
                }
                else{
                	exist[stack[tt].first-'a']=false;
                	--tt;
                }
            }
            
            else{
                stringstream stream(str);
                stream>>F>>i>>x>>y;
                if(exist[i[0]-'a']){
                	//cout<<"變量bug"<<endl;
                	error=true;  //已經有了該變量
                }
                else{
                    time=compute_time(x,y);
                    if(time>=0&&stack[tt].second>=0){
                        time=time+stack[tt].second;
                        maxTime=max(maxTime,time);
                    }else{
                    	time=-1;
                    }
                    stack[++tt]=Time{i[0],time}; 
                    exist[i[0]-'a']=true;
                }
                
            }
            
        }
        if(tt)error=true;
        if(error)cout<<"ERR"<<endl;
        else if(maxTime==O)cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
    return 0;
}

•  

第5節 偵探推理（毒瘤題）

明明同學最近迷上了偵探漫畫《柯南》並沉醉於推理遊戲之中，於是他召集了一羣同學玩推理遊戲。遊戲的內容是這樣的，明明的同學們先商量好由其中的一個人充當罪犯（在明明不知情的情況下），明明的任務就是找出這個罪犯。接着，明明逐個詢問每一個同學，被詢問者可能會說：

證詞中出現的其他話，都不列入邏輯推理的內容。

明明所知道的是，他的同學中有N個人始終說假話，其餘的人始終說真。

現在，明明需要你幫助他從他同學的話中推斷出誰是真正的兇手，請記住，兇手只有一個！

輸入描述:

輸入由若干行組成，第一行有二個整數，M（1≤M≤20）、N（1≤N≤M）和P（1≤P≤100）；M是參加遊戲的明明的同學數，N是其中始終說謊的人數，P是證言的總數。接下來M行，每行是明明的一個同學的名字（英文字母組成，沒有主格，全部大寫）。
往後有P行，每行開始是某個同學的名宇，緊跟着一個冒號和一個空格，後面是一句證詞，符合前表中所列格式。證詞每行不會超過250個字符。
輸入中不會出現連續的兩個空格，而且每行開頭和結尾也沒有空格。

輸出描述:

如果你的程序能確定誰是罪犯，則輸出他的名字；如果程序判斷出不止一個人可能是罪犯，則輸出 Cannot Determine；如果程序判斷出沒有人可能成爲罪犯，則輸出 Impossible。

示例1

輸入

3 1 5
MIKE
CHARLES
KATE
MIKE: I am guilty.
MIKE: Today is Sunday.
CHARLES: MIKE is guilty.
KATE: I am guilty.
KATE: How are you??

輸出

MIKE

本題給的規則很詳盡但是未知信息太多。誰會是兇手？哪些人說謊？今天周幾？由於有未知信息無法推斷得到，因爲枚舉法是這題的基本思想，同時數據規模也給足了枚舉的提示。但是，我們還是需要對三個基本問題進行分析，首先，如果我們知道兇手和周幾就可以推斷出某個人有沒有說謊，所以，我們只需要枚舉兇手和周幾足矣。

思路：枚舉兇手、枚舉周幾，統計可能爲兇手的人數，需要判定的信息有兩個：

1.對於每個人，要麼從頭到尾說謊，要麼一直都說真話

2.說謊的人數是否足夠，注意坑點：有可能有人至始至終沒有說過話，設這部分人的數量爲other，設我們判斷出的說謊者人數爲fake，那麼應滿足fake<=N<=fake+other。（至少fake個人說謊，至多沒說話的人也屬於說謊者，就是other+fake【當然這個自相矛盾，沒說話怎麼判定說謊沒說謊，問出題人吧->->】）。

代碼他來了->->，別問我爲什麼不優化（數據量太小了，優化效果不明顯，而且優化起來代碼複雜度簡直不忍直視，另外，變量名命名多好，寫這種毒瘤題就多輕鬆）：

#include<string>
#include<cstring>
#include<iostream>
using namespace std;

const int N=110;

string weekday[8]={
    "",
    "Today is Monday.",
    "Today is Tuesday.",
    "Today is Wednesday.",
    "Today is Thursday.",
    "Today is Friday.",
    "Today is Saturday.",
    "Today is Sunday."
};
string name[N];
string sentence[N];//存儲句子
int state[N],m,n,p,murder_name,murder_count;//state:-1 未說話  0:說真話  1:說假話

int get_person(string Name){ //根據姓名找到索引
    for(int i=1;i<=m;++i){
        if(Name==name[i])return i;
    }
    return -1;
}

int get_state(int murder,int day,int now_person,string now_word){//根據實際兇手 今日周幾 當前發言人 當前發言判定當前人有沒有說謊
    
  //  cout<<"兇手:"<<name[murder]<<" day:"<<day<<" 發言人:"<<name[now_person]<<" 發言:"<<now_word<<endl;
    
    if(now_word=="I am guilty."){//發言人說自己是罪犯
        if(murder==now_person){//兇手確實是發言人 沒有說謊
            return 0;
        }
        return 1;
    }
    
    if(now_word=="I am not guilty."){
        if(murder!=now_person){//兇手確實不是發言人 沒有說謊
            return 0;
        }
        return 1;
    }
    
    int t=now_word.find(" is guilty."),word_murder;
    
    if(t!=-1){//當前發言人指認別人是兇手
        word_murder=get_person(now_word.substr(0,t));//難道指認對象的索引
        if(murder==word_murder){//指認正確
            return 0;
        }
        return 1;
    }
    
    t=t=now_word.find(" is not guilty.");
    if(t!=-1){//當前發言人指認別人不是兇手
        word_murder=get_person(now_word.substr(0,t));//難道指認對象的索引
        if(murder!=word_murder){//指認正確
            return 0;
        }
        return 1;
    }
    
    //判斷是周幾
    for(t=1;t<=7;++t){
        if(weekday[t]==now_word){
            if(t==day){//周幾判斷正確
                return 0;
            }
            return 1;
        }
    }
    
    return -1;//說了些無關的話，無法判斷是否說謊 
}

pair<int,string> deal_sentence(string word){
    int t=word.find(":");
    int person=get_person(word.substr(0,t));
    return make_pair(person,word.substr(t+2));
}

bool check(int murder,int day){//檢查這兩個條件下 是否可以成立
    memset(state,-1,sizeof(state));
    pair<int,string> murder_word;
    int i,s,now;
    for(i=1;i<=p;++i){//處理每個句子
        
        murder_word=deal_sentence(sentence[i]);
        now=murder_word.first;
        s=get_state(murder,day,now,murder_word.second);
        
        if(s==0){//沒有說話
            if(state[now]==1){//之前說過謊
                return false;
            }
            state[now]=0;
        }
        if(s==1){
            if(state[now]==0){
                return false;
            }
            state[now]=1; 
        }
    }
    
    int fake=0,other=0;
    for(i=1;i<=m;++i){
        if(state[i]==1)++fake;
        else if(state[i]==-1)++other;
    }
    return (n>=fake)&&(n<=fake+other);
}

int main(){
    
    int i,j;
    cin>>m>>n>>p;
    
    for(i=1;i<=m;++i)cin>>name[i];

    for(i=0;i<=p;++i)getline(cin,sentence[i]);//用sentence[0]讀掉回車
    
    for(i=1;i<=m;++i){  //枚舉兇手
        for(j=1;j<=7;++j){ //枚舉周幾
            if(check(i,j)){//如果i是兇手 今天是周j 能夠成立 
                ++murder_count;
                murder_name=i;
                break;
            }
        }
    }
    
    if(!murder_count)cout<<"Impossible";
    else if(murder_count==1)cout<<name[murder_name];
    else cout<<"Cannot Determine";
    
    return 0;
}