1 #include <stdio.h> 
  2 #include <string.h>
  3 #include <sstream>
  4 #include <algorithm>
  5 using namespace std;
  6 struct INFO
  7 {
  8     char ch;
  9     int nValue;
 10     char chAdd;
 11     bool operator < (const INFO& info) const
 12     {
 13         return ch < info.ch;
 14     }
 15 };
 16 
 17 INFO infos[200];
 18 char szLine[200];
 19 
 20 bool GetNextChar(stringstream& ss, char& ch)
 21 {
 22     while (ss >> ch)
 23     {
 24         if (ch != ' ');
 25         {
 26             return true;
 27         }
 28     }
 29     return false;
 30 }
 31 
 32 int main()
 33 {
 34     while (gets(szLine))
 35     {
 36         printf("Expression: %s\n", szLine);
 37         memset(infos, 0, sizeof(infos));
 38         stringstream ss(szLine);
 39         char ch;
 40         int nNum = 0;
 41         int nValue = 0;
 42         char chOper;
 43         bool bOk = true;
 44         bool bFirst = true;
 45         while (1)
 46         {
 47             if (bFirst)
 48             {
 49                 chOper = '+';
 50                 bFirst = false;
 51             }
 52             else
 53             {
 54                 bOk = GetNextChar(ss, ch);
 55                 if (!bOk) break;
 56                 chOper = ch;
 57             }
 58 
 59             bOk = GetNextChar(ss, ch);
 60             if (!bOk) break;
 61 
 62             if (ch == '-')//前置--
 63             {
 64                 bOk = GetNextChar(ss, ch);
 65                 if (!bOk) break;//-
 66                 bOk = GetNextChar(ss, ch);
 67                 if (!bOk) break;//读取字母
 68 
 69                 infos[nNum].ch = ch;
 70                 infos[nNum].nValue = ch - 'a';
 71 
 72                 if (chOper == '+')
 73                 {
 74                     nValue += infos[nNum].nValue;
 75                 }
 76                 else
 77                 {
 78                     nValue -= infos[nNum].nValue;
 79                 }
 80                 ++nNum;
 81             }
 82             else if (ch == '+')//前置++
 83             {
 84                 bOk = GetNextChar(ss, ch);
 85                 if (!bOk) break;//+
 86                 bOk = GetNextChar(ss, ch);
 87                 if (!bOk) break;//读取字母
 88 
 89                 infos[nNum].ch = ch;
 90                 infos[nNum].nValue = ch - 'a' + 2;
 91 
 92                 if (chOper == '+')
 93                 {
 94                     nValue += infos[nNum].nValue;
 95                 }
 96                 else
 97                 {
 98                     nValue -= infos[nNum].nValue;
 99                 }
100                 ++nNum;
101             }
102             else
103             {
104                 infos[nNum].ch = ch;
105                 infos[nNum].nValue = ch - 'a' + 1;
106 
107                 if (chOper == '+')
108                 {
109                     nValue += infos[nNum].nValue;
110                 }
111                 else
112                 {
113                     nValue -= infos[nNum].nValue;
114                 }
115 
116                 //读取后置操作符
117                 char chOne;
118                 char chTwo;
119                 bOk = GetNextChar(ss, chOne);
120                 if (!bOk)
121                 {
122                     ++nNum;
123                     break;
124                 }
125                 bOk = GetNextChar(ss, chTwo);
126                 if (!bOk)
127                 {
128                     ++nNum;
129                     break;
130                 }
131 
132                 if (chOne == chTwo)
133                 {
134                     if (chOne == '+')
135                     {
136                         infos[nNum].chAdd = '+';
137                     }
138                     else
139                     {
140                         infos[nNum].chAdd = '-';
141                     }
142                 }
143                 else
144                 {
145                     ss.putback(chTwo);
146                     ss.putback(chOne);
147                 }
148                 ++nNum;
149             }
150         }
151 
152         printf("    value = %d\n", nValue);
153         sort(infos, infos + nNum);
154         for (int i = 0; i < nNum; ++i)
155         {
156             if (infos[i].chAdd == '+')
157             {
158                 infos[i].nValue++;
159             }
160             else if (infos[i].chAdd == '-')
161             {
162                 infos[i].nValue--;
163             }
164             printf("    %c = %d\n", infos[i].ch, infos[i].nValue);
165         }
166     }
167 
168     return 0;
169 }
170 

yx 2012-07-10 12:05 发表评论

#include <stdio.h> 
#include <math.h>
unsigned long long s2[101];
unsigned long long r2[101];
unsigned long long s3[101];
unsigned long long r3[101];
unsigned long long s4[101];
unsigned long long r4[101];

int main()
{
    unsigned long long i = 0;
    while (i <= 100)
    {
        s2[i] = i * (i + 1) * (2 * i + 1) / 6;//平方和
        s3[i] = i * i * (i + 1) * (i + 1) / 4;//立方和
        s4[i] = i * (i + 1) * (6 * i * i * i + 9 * i * i + i - 1) / 30;//四次方和
        r2[i] = pow(i * (i + 1) / 2, 2) - s2[i];
        r3[i] = pow(i * (i + 1) / 2, 3) - s3[i];
        r4[i] = pow(i * (i + 1) / 2, 4) - s4[i];
        ++i;
    }
    
    int nN;
    while (scanf("%d", &nN) != EOF)
    {
        //printf("%I64u %I64u %I64u %I64u %I64u %I64u\n", s2[nN], r2[nN], s3[nN], r3[nN], s4[nN], r4[nN]);
        printf("%llu %llu %llu %llu %llu %llu\n", s2[nN], r2[nN], s3[nN], r3[nN], s4[nN], r4[nN]);
    }
    
    return 0;
}

yx 2012-04-14 21:00 发表评论

关于Floyd算法,可以这样理解...比如刚开始只取2个结点i,j,它们的距离一定是dis(i,j),但是还有其它结点,需要把其它结点也慢慢加进来,所以最外层关于k的循环意思就是从0至nN-1,把所有其它结点加进来,比如加入0号结点后,距离dis(i,0)+dis(0,j)可能会比dis(i,j)小,如果是这样就更新dis(i,j),然后后面加入1号结点的时候,实际上是在已经加入0号结点的基础上进行的处理了,效果变成dis(i,0,1,j),可能是最小的,而且中间的0,1也可能是不存在的,当然是在dis(i,j)原本就是最小的情况下...
这个算法可以用下面这个图片描述...


解法3:

yx 2011-12-04 22:20 发表评论

yx 2011-11-24 00:47 发表评论

yx 2011-11-20 23:09 发表评论

#include <stdio.h>
#include <string.h>
#include <algorithm>

using std::sort;
bool Greater(int one, int two)
{
    return one > two;
}

int main()
{
    char szOne[110];
    char szTwo[110];
    int nNumOne[26];
    int nNumTwo[26];
    
    while (scanf("%s%s", szOne, szTwo) == 2)
    {
        memset(nNumOne, 0, sizeof(int) * 26);
        memset(nNumTwo, 0, sizeof(int) * 26);
        
        char* psz = szOne;
        while (*psz)
        {
            ++nNumOne[*psz - 'A'];
            ++psz;
        }
        psz = szTwo;
        while (*psz)
        {
            ++nNumTwo[*psz - 'A'];
            ++psz;
        }
        sort(nNumOne, nNumOne + 26, Greater);
        sort(nNumTwo, nNumTwo + 26, Greater);
        bool bIsYes = true;
        for (int i = 0; i < 26; ++i)
        {
            if (nNumOne[i] < nNumTwo[i])
            {
                bIsYes = false;
                break;
            }
        }
        if (bIsYes)
        {
            printf("YES\n");
        }
        else
        {
            printf("NO\n");
        }
    }
    
    return 0;
}

yx 2011-11-18 16:04 发表评论

#include <stdio.h>
#include <string.h>
#include <algorithm>

#define MAX_WORD_LEN 11
#define MAX_DICTION_ITEM (100000 + 10)

using std::sort;

struct Dictionary
{
    char szWord[MAX_WORD_LEN];
    char szEnglish[MAX_WORD_LEN];
};

Dictionary diction[MAX_DICTION_ITEM];

bool CmpDictionItem(Dictionary one, Dictionary two)
{
    return strcmp(one.szWord, two.szWord) < 0;
}

int FindEnglish(char* pszWord, int nItemNum)
{
    int nBeg = 0, nEnd = nItemNum - 1;
    int nCmp = 0;
    
    while (nBeg <= nEnd)
    {
        int nMid = (nBeg + nEnd) / 2;
        nCmp = strcmp(pszWord, diction[nMid].szWord);
        if (nCmp == 0)
        {
            return nMid;
        }
        else if (nCmp < 0)
        {
            nEnd = nMid - 1;
        }
        else
        {
            nBeg = nMid + 1;
        }
    }
    
    return -1;
}

int main()
{
    char szStr[30];
    char szWord[MAX_WORD_LEN];
    int nCount = 0;
    int nAnsItem = 0;
    
    while (fgets(szStr, 29, stdin), szStr[0] != '\n')
    {
        sscanf(szStr, "%s%s", diction[nCount].szEnglish, diction[nCount].szWord);
        ++nCount;
    }
    sort(diction, diction + nCount, CmpDictionItem);
    while (scanf("%s", szWord) == 1)
    {
        if ((nAnsItem = FindEnglish(szWord, nCount)) != -1)
        {
            printf("%s\n", diction[nAnsItem].szEnglish);
        }
        else
        {
            printf("eh\n"); 
        }
    }
    
    return 0;
}

其实我的主要目的是为了指出二分的写法,大家看我的FindEnglish函数,传递的是数组的地址和数组的长度,
然后我写函数体的时候用的是[]的形式,就是下确界,上确界,这样最重要的是需要考虑循环的条件是<还是
<=,其实这也很好判断,因为上界和下界都能够取到,所以=是成立的...而且修改right的时候,必须将right = mid - 1,
原因也是因为这是上确界,
但是如果是上不确界了,那么等号就必须去掉,而且right也只能修改为mid,因为mid-1就是确界了,而mid才是上不确界...
想到这个程度的话,以后写只有唯一解二分就应该不会出错了...但是写查找满足条件的最大或者最小解的二分还需要其它技巧...

yx 2011-11-16 13:52 发表评论

#include <stdio.h>

#define SMALL (365 * 3 + 366)
#define MID   (SMALL * 25 - 1)
#define BIG (MID * 4 + 1)

char* pszWeekdays[7] =
{
    "Saturday", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday"
};

int nDaysOfMon[2][13] =
{
    {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
    {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};

void GetMonthAndDay(int nDays, bool bIsLeap, int* nMon, int* nDay)
{
    int nChoose = 0;
    int i = 0;

    if (bIsLeap)
    {
        nChoose = 1;
    }
    *nMon = *nDay = 0;
    i = 1;
    while (nDays > nDaysOfMon[nChoose][i])
    {
        nDays -= nDaysOfMon[nChoose][i];
        ++i;
    }
    *nMon = i;
    *nDay = nDays;
}

void CountSmall(int* pnDays, int* pnPastYears, int* pnMon, int* pnDay)
{
    if (*pnDays >= 3 * 365)//4
    {
        *pnPastYears += 3;
        *pnDays -= 365 * 3;
        GetMonthAndDay(*pnDays + 1, true, pnMon, pnDay);
    }
    else//1-3
    {
        *pnPastYears += *pnDays / 365;
        *pnDays %= 365;
        GetMonthAndDay(*pnDays + 1, false, pnMon, pnDay);
    }
}

int main()
{
    int nPastDays = 0;
    int nPastYears = 0;
    int nYear = 0, nMon = 0, nDay = 0;

    while (scanf("%d", &nPastDays), nPastDays != -1)
    {
        int nTemp = nPastDays;
        nPastYears = 0;

        if (nTemp < 366)
        {
            GetMonthAndDay(nTemp + 1, true, &nMon, &nDay);
            nPastYears = 0;
        }
        else
        {
            nPastYears++;
            nTemp -= 366;

            nPastYears += (nTemp / BIG) * 400;
            nTemp %= BIG;

            if (nTemp >= MID * 3)//301-400年(以4为周期)
            {
                nTemp -= MID * 3;
                nPastYears += 300;

                nPastYears += nTemp / SMALL * 4;
                nTemp %= SMALL;

                CountSmall(&nTemp, &nPastYears, &nMon, &nDay);
            }
            else//1-300年
            {
                nPastYears += nTemp / MID * 100;
                nTemp %= MID;

                if (nTemp >= SMALL * 24)//97-100年(4个平年)
                {
                    nTemp -= SMALL * 24;
                    nPastYears += 4 * 24;

                    nPastYears += nTemp / 365;
                    nTemp %= 365;
                    GetMonthAndDay(nTemp + 1, false, &nMon, &nDay);

                }
                else//1-96年
                {
                    nPastYears += nTemp / SMALL * 4;
                    nTemp %= SMALL;

                    CountSmall(&nTemp, &nPastYears, &nMon, &nDay);
                }
            }
        }
        printf("%d-%02d-%02d %s\n", nPastYears + 2000, nMon, nDay, pszWeekdays[nPastDays % 7]);
    }

    return 0;
}

yx 2011-11-16 13:09 发表评论

yx 2011-11-10 20:56 发表评论

这样的写法显然不好吧。。。首先,余下1,2,3个3*3时候需要填几个2*2的可以存储在数组里面,这样就可以不用写重复代码了,
如果再从整体考虑余下多少个格子,就不用用贪心算法模拟装箱子的过程了。。。
代码如下:

yx 2011-11-08 20:15 发表评论

yx 2011-11-07 13:27 发表评论