庞果网--编程挑战系列

题目链接：http://hero.pongo.cn/

寻找直方图中面积最大的矩形

思路：直接遍历，对于某一个直条图，搜索前面比他高的矩形数目，搜索后面比他高的矩形数目，面积就是这些矩形数目乘以当前矩形的高度，在比较求最大值

int largestRectangleArea(const int *height,int n)
{
    int result;
    int low=0;
    for(int i=0;i<n;i++)
    {
        int w=1;
        for(int j=i-1;j>=0;j--)
        {
            if(height[i]>height[j])break;
            else w++;
        }
        for(int j=i+1;j<n;j++)
        {
            if(height[i]>height[j])break;
            else w++;
        }
        result=height[i]*w;
        if(result>low)low=result;
    }
    return low;
}

倒水问题

思路：就是一个扩展欧几里得算法，只需要c能整除最大公约数

__int64 ex_gcd(__int64 a,__int64 b,__int64 &x,__int64 &y)
{
    if(!b)
    {
        x=1,y=0;
        return a;
    }
    __int64 r=ex_gcd(b,a%b,x,y);
    __int64 t=x;
    x=y;
    y=t-a/b*y;
    return r;
}

字符串完美度

思路：统计字符数目，在排序，从高到低依次给定完美度为26,25.，24.....

int num[27];
void init()
{
    memset(num,0,sizeof(num));
}
int perfect(const string &s) {
    int len=s.length();
    init();
    for(int i=0;i<len;i++)
    {
        int k;
        if(s[i]>='A'&&s[i]<='Z')
        {
            k=s[i]+32-'a'+1;
        }
        else k=s[i]-'a'+1;
        num[k]++;
    }
    sort(num+1,num+27);
    /*for(int i=0;i<26;i++)
    {
        cout<<num[i]<<" ";
    }
    cout<<endl;*/
    int sum=0;
    for(int i=26;i>=1;i--)
    {
        sum+=num[i]*i;
       // cout<<num[i]<<" "<<i<<endl;
       // cout<<sum<<" ";
    }
    return sum;
}

数字取反

思路：取余

int solve(int n)
{
    int k;
    int t=0;
    int m=n;
    m=m<0?-m:m;

    while(m!=0)
    {
        k=m%10;
        t=t*10+k;
        m=m/10;
    }
    if(n<0)return -t;
    return t;
}

int reverse(int x)
{
    //wirte your code here
    solve(x);
}

回文串数目：

思路：先统计字符数目，由回文定义可知，对于奇数个的字符，其中必有一个放在中央

例如aaaabbbbccccddddd，那么可知中间的一定是d，即########d########的形式，那么对于前一半，我们根据组合计数的乘法原理可知有C(8，2)*C（6,2）*C(4，2)*C(2，2),前面确定了，后面就同时确定呢，同时，内部包含的每个字符的个数为奇数的数量，不能超过1个

#define mod 1000000007
int combine(int n, int m)//直接求
{
    int result1 = 1,result2 = 1;
    for (int i = 1; i <= m; i ++)
    {
        result1 = result1 * n;
        result2 = result2 *i;
        n --;
    }
    return result1 / result2;
}

int combine1(int n,int m)//求C（n,m）会溢出
{
    int result=1;
    for(int i=1; i<=m; i++)
    {
        result*=(n-i+1)/i;
    }
    return result;
}

int palindrome(const string &s)
{
    int count=0;
    long long result=1;
    int num[26];
    int len=s.length();
    memset(num,0,sizeof(num));

    for(int i=0; i<len; i++)
    {
        num[s[i]-'a']++;
    }
    for(int i=0; i<26; i++)
    {
        if(num[i]%2==1)
        {
            count++;
        }
        num[i]=num[i]/2;
    }
    if(count>1)return 0;
    else
    {
        int k=len/2;
        for(int i=0; i<26; i++)
        {
            if(num[i]>0)
            {
                result*=combine(k,num[i]);
                result%=mod;
                k-=num[i];
            }
        }
    }
    return result;
}

数组排序

思路：直接比较判断是不是在他的本身位置，不在必定交换

int  run(const int *a,int n)
{
    int *b =new int[n];
    for(int i=0;i<n;i++)
    {
        b[i]=a[i];
    }
    int count=0;
    for(int i=0;i<n;i++)
    {
        for(int j=i;j<n;j++)
        {
            if(b[j]==i+1&&j!=i)
            {
                count++;
                swap(b[j],b[i]);
            }
        }
    }
    delete []b;
    b=NULL;
    return count;
}