B - B

內容：

    One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall into several parts. Some parts were painted red and all the other were painted blue. Besides, any two neighboring parts were painted different colors, that is
 
, the red and the blue color were alternating, i. e. followed one after the other. The outer area of the wall (the area that lied outside all circles) was painted blue. Help Sherlock Holmes determine the total area of red parts of the wall.

    Let us remind you that two circles are called concentric 
 
if their centers coincide. Several circles are called concentric if any two of them are concentric.
Input

    The first line contains the single integer n (1 ≤ n ≤ 100). The second line contains n space-separated integers ri (1 ≤ ri ≤ 1000) — the circles' radii. It is guaranteed that all circles are different.
 

Output

    Print the single real number — total area of the part of the wall that is painted red. The answer is accepted if absolute or relative error doesn't exceed 10 - 4.
Examples
    Input

    1
    1

    Output

    3.1415926536

    Input

    3
    1 4 2

    Output

    40.8407044967

Note

    In the first sample the picture is just one circle of radius 1. Inner part of the circle is painted red. The area of the red part equals π × 12 = π.

    In the second sample there are three circles of radii 1, 4 and 2. Outside part of the second circle is painted blue. Part between the second and the third circles is painted red. Part between the first and the third is painted blue. And, finally, the inner part of the first circle is painted red. Overall there are two red parts: the ring between the second and the third circles and the inner part of the first circle. Total area of the red parts is equal (π × 42 - π × 22) + π × 12 = π × 12 + π = 13π

水題，但是因為我把一個‘ * ’號寫成了‘ - ’號沒發現導致wa了好幾次，還以為是超時了，氣死。。。

程式碼：

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<math.h>
using namespace std;
int main()
{
    int n;
    cin>>n;
    int s[n+5];
    for(int i=0;i<n;i++)
    {
        cin>>s[i];
    }
    sort(s,s+n,greater<int>());
    double sum=0,p=3.141592653589;
    if(n%2==0)
    {
        for(int i=0;i<n-1;i+=2)
        {
            sum+=p*(s[i]*s[i]-s[i+1]*s[i+1]);
        }
        printf("%.9lf\n",sum);
    }
    else{
        for(int i=0;i<n-2;i+=2)
        {
            sum+=p*(s[i]*s[i]-s[i+1]*s[i+1]);//就是這裡最後一個*號弄錯了。。。
        }
        sum+=p*s[n-1]*s[n-1];
        printf("%.9lf\n",sum);
    }
}

C - C

內容：

    Dr. Moriarty is about to send a message to Sherlock Holmes. He has a string s.

    String p is called a substring of string s if you can read it starting from some position in the string s. For example, string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".

    Dr. Moriarty plans to take string s and cut out some substring from it, let's call it t. Then he needs to change the substring t zero or more times. As a result, he should obtain a fixed string u (which is the string that should be sent to Sherlock Holmes). One change is defined as making one of the following actions:

        Insert one letter to any end of the string.
        Delete one letter from any end of the string.
        Change one letter into any other one.

    Moriarty is very smart and after he chooses some substring t, he always makes the minimal number of changes to obtain u.

    Help Moriarty choose the best substring t from all substrings of the string s. The substring t should minimize the number of changes Moriarty should make to obtain the string u from it.
Input

    The first line contains a non-empty string s, consisting of lowercase Latin letters. The second line contains a non-empty string u, consisting of lowercase Latin letters. The lengths of both strings are in the range from 1 to 2000, inclusive.
Output

    Print the only integer — the minimum number of changes that Dr. Moriarty has to make with the string that you choose.
Examples
    Input

    aaaaa
    aaa

    Output

    0

    Input

    abcabc
    bcd

    Output

    1

    Input

    abcdef
    klmnopq

    Output

    7

Note

    In the first sample Moriarty can take any substring of length 3, and it will be equal to the required message u, so Moriarty won't have to make any changes.

    In the second sample you should take a substring consisting of characters from second to fourth ("bca") or from fifth to sixth ("bc"). Then you will only have to make one change: to change or to add the last character.

    In the third sample the initial string s doesn't contain any character that the message should contain, so, whatever string you choose, you will have to make at least 7 changes to obtain the required message.

題目大意：給出兩個字串s,u,通過將s中提取出的子字串t 經過在任意一端刪除字元，或在兩端增加字元或者改變任意字元，使得t等於u；求最小運算元。

思路：順序找到最長的匹配字元個數，再用len2減去，所得結果就是最少運算元。

程式碼：

#include<bits/stdc++.h>
using namespace std;
int main()
{
    string s,t;
    while(cin>>s>>t)
    {
        int len1=s.length(),len2=t.length();
        int ans=1e9,i,j,len=len2;
        for(i=0;i<len1;i++)
        {
            int k,ct=0;
            for(k=0,j=i;k<len2&&j<len1;k++,j++)
            {
                if(t[k]==s[j])
                    ct++;
            }
            ans=min(ans,len-ct);
        }
        for(i=0;i<len2;i++)
        {
            int k,ct=0;
            for(k=0,j=i;k<len1&&j<len2;k++,j++)
            {
                if(t[j]==s[k])
                    ct++;
            }
            ans=min(ans,len-ct);
        }
        cout<<ans<<endl;
    }
}

D - D

    As Sherlock Holmes was investigating a crime, he identified n suspects. He knows for sure that exactly one of them committed the crime. To find out which one did it, the detective lines up the suspects and numbered them from 1 to n. After that, he asked each one: "Which one committed the crime?". Suspect number i answered either "The crime was committed by suspect number ai", or "Suspect number ai didn't commit the crime". Also, the suspect could say so about himself (ai = i).

    Sherlock Holmes understood for sure that exactly m answers were the truth and all other answers were a lie. Now help him understand this: which suspect lied and which one told the truth?
Input

    The first line contains two integers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ n) — the total number of suspects and the number of suspects who told the truth. Next n lines contain the suspects' answers. The i-th line contains either "+ai" (without the quotes), if the suspect number i says that the crime was committed by suspect number ai, or "-ai" (without the quotes), if the suspect number i says that the suspect number ai didn't commit the crime (ai is an integer, 1 ≤ ai ≤ n).

    It is guaranteed that at least one suspect exists, such that if he committed the crime, then exactly m people told the truth.
Output

    Print n lines. Line number i should contain "Truth" if suspect number i has told the truth for sure. Print "Lie" if the suspect number i lied for sure and print "Not defined" if he could lie and could tell the truth, too, depending on who committed the crime.
Examples
    Input

    1 1
    +1

    Output

    Truth

    Input

    3 2
    -1
    -2
    -3

    Output

    Not defined
    Not defined
    Not defined

    Input

    4 1
    +2
    -3
    +4
    -1

    Output

    Lie
    Not defined
    Lie
    Not defined

Note

    The first sample has the single person and he confesses to the crime, and Sherlock Holmes knows that one person is telling the truth. That means that this person is telling the truth.

    In the second sample there are three suspects and each one denies his guilt. Sherlock Holmes knows that only two of them are telling the truth. Any one of them can be the criminal, so we don't know for any of them, whether this person is telling the truth or not.

    In the third sample the second and the fourth suspect defend the first and the third one. But only one is telling the truth, thus, the first or the third one is the criminal. Both of them can be criminals, so the second and the fourth one can either be lying or telling the truth. The first and the third one are lying for sure as they are blaming the second and the fourth one.

題意：

題意：福爾摩斯正在處理一件案子。此時已經抓捕了n個嫌疑人，裡面只可能有一個是真正的犯人。福爾摩斯正在審問這些嫌疑人。
每個嫌疑人的回答只有兩種，一種表明他說編號為i的嫌疑人不是犯人，用-i表示；另一種表明他說編號為i的嫌疑人是犯人，
用+i表示。聰明的福爾摩斯已經知道了其中有m個人說的是真話。要求那些人說的是真話，那些人說的是假話
思路：

首先判斷每個人是逃犯的情況符不符合m個人說實話
然後判斷合適的情況有多少
判斷一個人是不是逃犯只要判斷他被人說是逃犯和不說他是逃犯的人和等於m就可以了，因為如果他是逃犯那麼這些人都沒說謊。
然後通過可能發生的的事情的數量判斷每個人說沒說謊
如果一個人說另一個人是逃犯而這個人不可能是逃犯那麼就是說謊
如果一個人說另一個人是逃犯而這個人確實可能是逃犯那麼這個人說的話就不被確定
如果一個人說另一個人是逃犯而可能的事實只有一種那麼他卻說的就是實話而這個人是對的
如果一個人說其他人不是逃犯而這個人可能是逃犯那麼他說的話就是不確定的
如果一個人說另一個人不是逃犯而這個人不可能是逃犯那麼他說的就是對的
如果一個人說另一個人不是逃犯而這個人可能是逃犯並且事實唯一那麼他就說了謊那麼個人確實是逃犯

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int tu[100001], ky[100001], bky[100001], dui[100001],zgky=0,zgbky=0;
int main()
{
    int n, m;
    cin >> n >> m;
    for (int a = 1; a <= n; a++)
    {
        scanf("%d", &tu[a]);
        if (tu[a] < 0)bky[-tu[a]]++,zgbky++;
        else ky[tu[a]]++, zgky++;
    }
    int kn = 0;
    for (int a = 1; a <= n; a++)
    {
        if (ky[a] + zgbky - bky[a] == m)
        {
            kn++;
            dui[a] = 1;
        }
    }
    for (int a = 1; a <= n; a++)
    {
        if (tu[a] > 0)
        {
            if (!dui[tu[a]])printf("Lie\n");
            else if (kn > 1)printf("Not defined\n");
            else printf("Truth\n");
        }
        else
        {
            if(!dui[-tu[a]])printf("Truth\n");
            else if (kn > 1)printf("Not defined\n");
            else printf("Lie\n");
        }
    }
}