Hdu 4802 Hdu 4803 Hdu 4810 Hdu 4811

Hdu 4802:

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<map>
#include<algorithm>
using namespace std;

map<string,double>m;

double s,sum1,sum2;
string op;
int n;

int main()
{
    m["A"]=4.0,m["A-"]=3.7,m["B+"]=3.3,m["B"]=3.0;
    m["B-"]=2.7,m["C+"]=2.3,m["C"]=2.0,m["C-"]=1.7;
    m["D"]=1.3,m["D-"]=1.0,m["F"]=0;
    while(cin>>n)
    {
        sum1=0,sum2=0;
        for(int i=0;i<n;i++)
        {
            cin>>s>>op;
            if(op=="P"||op=="N")
                continue;
            sum2+=s;
            sum1+=s*m[op];
        }
        if(sum2==0)
            printf("0.00\n");
        else
            printf("%.2lf\n",sum1/sum2);
    }
}


Hdu 4811:  YY出来的.....因为在修改的过程中scanf里面多了一个"%",贡献了几次WA....冲动是魔鬼....


#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

long long  a[3];
int main()
{
    while(~scanf("%I64d%I64d%I64d",&a[0],&a[1],&a[2]))
    {
       long long  n=a[0]+a[1]+a[2];
      // printf("%I64d %I64d %I64d\n",a[0],a[1],a[2]);
        sort(a,a+3);
        if(a[2]==0)
            printf("0\n");
        else if(a[1]==0)
        {
            if(a[2]==1)
                printf("0\n");
            else
                printf("%I64d\n",1+(n-2)*2);
        }
        else if(a[0]==0)
        {
            if(a[1]==1)
            {
                if(a[2]==1)
                    printf("1\n");
                else
                    printf("%I64d\n",1+2+(n-3)*3);
            }
            else
                printf("%I64d\n",1+2+3+(n-4)*4);
        }
        else
        {
            if(a[0]>=2)
            {
                printf("%I64d\n",15+(n-6)*6);
            }
            else if(a[0]==1)
            {
                if(a[1]==1)
                {
                    if(a[2]==1)
                    {
                        printf("%I64d\n",1*1LL+2);
                    }
                    else
                    {
                        printf("%I64d\n",1+2+3+(a[2]-2)*4);
                    }
                }
                else
                {
                    printf("%I64d\n",1+2+3+4+(n-5)*5);
                }
            }
        }
    }
    return 0;
}


Hdu 4810:

对于样例,我们把它变成2进制:

0 0  0 1

0 0  1 0

1 0 1 0

0 0 0 1

统计每一位1的个数,对于二进制的每一位,我们选出k个数,如果里面有奇数个1,那么说明异或后,结果不是0,反之.....

交了后WA了,但觉得想法没问题,就改一点交一点,WA了好多次.......因为忘记了C[i][j]当j>i时,是0,其实根本就不应该跑到这一步的,,,,,,,


#include<stdio.h>
#include<string.h>
#include<map>
#include<algorithm>
using namespace std;
#define mod 1000003
int n;
int a[1001];
long long ans[1001];
int sum;
long long c[1001][1001];
int num[33];

inline void init()
{
    memset(c,0,sizeof(c));
    c[0][0]=1;
    for(int i=1;i<=1000;i++) c[i][0]=1,c[i][i]=1;
    for(int i=2;i<=1000;i++)
        for(int j=1;j<i;j++)
            c[i][j]=(c[i-1][j-1]+c[i-1][j])%mod;

}
inline void chuli(int t)
{
    int val=t;
    int s=1;
    while(val)
    {
        if(val%2)
            num[s]++;
        val/=2;
        s++;
    }
}
int main()
{
    init();
    while(~scanf("%d",&n))
    {
        memset(ans,0,sizeof(ans));
        memset(num,0,sizeof(num));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            chuli(a[i]);
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=32;j++)
            {
                for(int k=1;k<=i;k+=2)
                    ans[i]+=(c[num[j]][k]*(c[n-num[j]][i-k])%mod)*((1*1LL)<<(j-1) %mod),ans[i]%=mod;
            }
        }
        for(int i=1;i<=n;i++)
        {
            printf("%I64d",ans[i]%mod);
            if(i==n)
                printf("\n");
            else
                printf(" ");
        }
    }
}


Hdu 4803:这道我没有正常的想法,不过看到x很小,所以决定先算出小范围的解,我算出了 x<=10,y<=50的解,然后,居然找到了规律......再几次修改之后,居然过了.......


#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;

int x,y;
int main()
{
    while(~scanf("%d%d",&x,&y))
    {
        if(y<x) printf("-1\n");
        else if(x==1) printf("%d\n",y-1);
        else
        {
            if(x==2)
                printf("%d\n",(y+1)/2);
            else if(x==3)
            {
                int a[3]={2,3,4};
                printf("%d\n",(y-3)/3+a[(y-3)%3]);
            }
            else if(x==4)
            {
                int a[4]={3,4,4,5};
                printf("%d\n",(y-4)/4+a[(y-4)%4]);
            }
            else if(x==5)
            {
                int a[5]={4,5,5,6,6};
                printf("%d\n",(y-5)/5+a[(y-5)%5]);
            }
            else if(x==6)
            {
                int a[]={5,6,6,6,7,7};
                printf("%d\n",(y-6)/6+a[(y-6)%6]);

            }
            else if(x==7)
            {
                int a[7]={6,7,7,7,8,8,9};
                printf("%d\n",(y-7)/7+a[(y-7)%7]);
            }
            else if(x==8)
            {
                int a[8]={7,8,8,9,8,9,9,10};
                printf("%d\n",(y-8)/8+a[(y-8)%8]);
            }
            else if(x==9)
            {
                int a[9]={8,9,9,9,9,10,10,10,11};
                printf("%d\n",(y-9)/9+a[(y-9)%9]);
            }
            else if(x==10)
            {
                int a[10]={9,10,10,10,11,10,11,11,11,12};
                printf("%d\n",(y-10)/10+a[(y-10)%10]);
            }
        }
    }
}


额,打表代码:

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;

struct node
{
    int x,y;
    double a,b;
    int t;
};
bool operator < (node i,node j)
{
    return i.t>j.t;
}
int x,y;
int main()
{
    int ans[100][100];
    memset(ans,-1,sizeof(ans));
    for(int i=2;i<=10;i++)
        for(int j=i;j<=50;j++)
    {
        priority_queue<node>q;
        node v,vv,vvv;
        v.x=v.y=1;
        v.a=v.b=1.0;
        v.t=0;
        q.push(v);
        int flag=-1;
        while(!q.empty())
        {
            v=q.top();
            q.pop();
            if(v.x==i&&v.y==j)
            {
                flag=v.t;break;
            }
            if(v.x>i||v.y>j)
                continue;


            vv.b=(v.a+1)*(v.b/v.a);
            vv.a=v.a+1;
            vv.x=v.x+1;
            vv.y=int(vv.b+(1e-8));
            vv.t=v.t+1;
            //printf("%d %d %d %.2lf %.2lf\n",vv.x,vv.y,vv.t,vv.a,vv.b);
            if(vv.x==i&&vv.y==j)
            {
                flag=vv.t;break;
            }
            if(vv.x<=i&&vv.y<=j)
                q.push(vv);

            vvv.b=v.b+1.0;
            vvv.a=v.a;
            vvv.x=v.x;
            vvv.y=int(vvv.b+(1e-8));
            vvv.t=v.t+1;
//printf("%d %d %d %.2lf %.2lf\n",vvv.x,vvv.y,vvv.t,vvv.a,vvv.b);
            if(vvv.x==i&&vvv.y==j)
            {

                flag=vvv.t;break;
            }

            if(vvv.x<=i&&vvv.y<=j)
                q.push(vvv);
        }
        ans[i][j]=flag;
    }
    for(int i=2;i<=10;i++)
    {
        for(int j=i;j<=50;j++)
            printf("%d ",ans[i][j]);
            printf("\n\n");
    }
}


【6层】一字型框架办公楼(含建筑结构图、计算书) 1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md或论文文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。 5、资源来自互联网采集,如有侵权,私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md或论文文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。 5、资源来自互联网采集,如有侵权,私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证,保证能够正常运行; 2、项目问题、技术讨论,可以给博主私信或留言,博主看到后会第一时间与您进行沟通; 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用,尤其对于人工智能、计算机科学与技术等相关专业,更为适合; 4、下载使用后,可先查看README.md或论文文件(如有),本项目仅用作交流学习参考,请切勿用于商业用途。 5、资源来自互联网采集,如有侵权,私聊博主删除。 6、可私信博主看论文后选择购买源代码。
深度学习是机器学习的一个子领域,它基于人工神经网络的研究,特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征,这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分: 1. **神经网络(Neural Networks)**:深度学习的基础是人工神经网络,它是由多个层组成的网络结构,包括输入层、隐藏层和输出层。每个层由多个神经元组成,神经元之间通过权重连接。 2. **前馈神经网络(Feedforward Neural Networks)**:这是最常见的神经网络类型,信息从输入层流向隐藏层,最终到达输出层。 3. **卷积神经网络(Convolutional Neural Networks, CNNs)**:这种网络特别适合处理具有网格结构的数据,如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络(Recurrent Neural Networks, RNNs)**:这种网络能够处理序列数据,如时间序列或自然语言,因为它们具有记忆功能,能够捕捉数据中的时间依赖性。 5. **长短期记忆网络(Long Short-Term Memory, LSTM)**:LSTM 是一种特殊的 RNN,它能够学习长期依赖关系,非常适合复杂的序列预测任务。 6. **生成对抗网络(Generative Adversarial Networks, GANs)**:由两个网络组成,一个生成器和一个判别器,它们相互竞争,生成器生成数据,判别器评估数据的真实性。 7. **深度学习框架**:如 TensorFlow、Keras、PyTorch 等,这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数(Activation Functions)**:如 ReLU、Sigmoid、Tanh 等,它们在神经网络中用于添加非线性,使得网络能够学习复杂的函数。 9. **损失函数(Loss Functions)**:用于评估模型的预测与真实值之间的差异,常见的损失函数包括均方误差(MSE)、交叉熵(Cross-Entropy)等。 10. **优化算法(Optimization Algorithms)**:如梯度下降(Gradient Descent)、随机梯度下降(SGD)、Adam 等,用于更新网络权重,以最小化损失函数。 11. **正则化(Regularization)**:技术如 Dropout、L1/L2 正则化等,用于防止模型过拟合。 12. **迁移学习(Transfer Learning)**:利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就,但它也面临着一些挑战,如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值