hdu 5170 5171

hdu 5170题意： 给定四个整数 a,b,c,d; 要比较a^b 与c^d的大小，
如果数据小的话直接搞就行，现在数据比较大，可以两边同取对数比较；
但是要注意精度问题！

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

using namespace std;
int a,b,c,d;

int main()
{
    while(cin>>a>>b>>c>>d)
    {
       double tmp1=b*log10(a*1.0);
       double tmp2=d*log10(c*1.0);

       if(tmp1-tmp2>1e-9)
            printf(">\n");
       else if(tmp2-tmp1>1e-9)
            printf("<\n");
       else
            printf("=\n");
    }
    return 0;
}

hdu 5171 题意: 给定一个集合,里面的数可能会有重复，现在每次可以从中取出两个数a,b，再将a+b加入这个集合中，这个操作可以重复k次
最终集合表述为A={A1,A2,A3…..An}；
求sum=A1+A2+A2+A3+……+An的最大值；
贪心处理即可，即每次取出来的都是原来集合中的最大值和次大值，数据小直接模拟即可，现在数据有点大，递推公式：
用a1,b1分别表示原来集合中的最大值，次大值

第一次操作 a1+b1 加入集合
第二次操作 2a1+b1加入集合
第三次操作 3a1+2b1加入集合
第四次擦做 5a1+3b1加入集合
.
.
.
.
.
发现是fib数列，矩阵加速求前k项的和即可；

#include <iostream>
#include <stdio.h>
#include <string>
#include <string.h>
#include <algorithm>
const int MOD=1e7+7;
using namespace std;
typedef long long ll;
int a[100100];

struct matrix
{
  ll f[5][5];
};
matrix Co; //系数矩阵

matrix mul(matrix a,matrix b)
{
    matrix c;
    memset(c.f,0,sizeof(c.f));
    for(int i=0;i<4;i++)
     for(int j=0;j<4;j++)
      for(int k=0;k<4;k++)
        {
          c.f[i][j]+=(a.f[i][k]*b.f[k][j])%MOD;
          c.f[i][j]%=MOD;
        }
    return c;
}

matrix quick_mod(matrix a,int b)
{
   matrix s;
   memset(s.f,0,sizeof(s.f));
   for(int i=0;i<4;i++)s.f[i][i]=1;
   while(b)
   {
     if(b&1)s=mul(s,a);
     b>>=1;
     a=mul(a,a);
   }
   return s;
}

int main()
{
   int n,k;
   Co.f[0][0]=1,Co.f[0][1]=1,Co.f[0][2]=0;
   Co.f[1][0]=1,Co.f[1][1]=0,Co.f[1][2]=0;
   Co.f[2][0]=1,Co.f[2][1]=1,Co.f[2][2]=1;

   while(cin>>n>>k)
   {
      ll ans=0;
      int a1,b1;
      for(int i=1;i<=n;i++)
      {
        scanf("%d",&a[i]);
        ans=(ans+a[i])%MOD;
      }
      sort(a+1,a+1+n);
      a1=a[n],b1=a[n-1]; //最大值 次大值

      matrix tmp=Co;
             tmp=quick_mod(tmp,k);
      ll left=tmp.f[2][0]*1%MOD+tmp.f[2][1]*0%MOD+tmp.f[2][2]*0%MOD;
         ans=(ans+left*a1%MOD)%MOD;

             tmp=Co;
             tmp=quick_mod(tmp,k-1);
      ll right=tmp.f[2][0]*1%MOD+tmp.f[2][1]*0%MOD+tmp.f[2][2]*0%MOD;
         ans=(ans+(right+1)*b1%MOD)%MOD;
      printf("%I64d\n",ans);
   }
   return 0;
}