行星序列(seq)c++代码

#include<cstdio>
using namespace std;
struct edge
{
    int lson,rson;
    long long value,mul,add;
};
edge node[400001];
long long a[400001];
int n,p;
int read()
{
    int w=0,c=1;
    char ch=getchar();
    while (ch<'0' || ch>'9')
      {
        if (ch=='-')
          c=-1;
        ch=getchar();
      }
    while (ch>='0' && ch<='9')
      {
        w=w*10+ch-'0';
        ch=getchar();
      }
    return w*c;
}
void update(int s)
{
    node[s].value=(node[s*2].value+node[s*2+1].value)%p;
}
void build(int s,int l,int r)
{
    node[s].lson=l;
    node[s].rson=r;
    node[s].mul=1;
    if (l==r)
      {
        node[s].value+=a[l]%p;
        return;
      }
    build(s*2,l,(l+r)/2);
    build(s*2+1,(l+r)/2+1,r);
    update(s);
}
void pushdown(int s)
{
    long long multiple,addup;
    int t=node[s].rson-node[s].lson+1;
    if (t==1)
      return;
    multiple=node[s].mul;
    addup=node[s].add;
    node[s].mul=1;
    node[s].add=0;
    node[s*2].value=(node[s*2].value*multiple+addup*(t-t/2))%p;
    node[s*2+1].value=(node[s*2+1].value*multiple+addup*(t/2))%p;
    node[s*2].mul=(node[s*2].mul*multiple)%p;
    node[s*2+1].mul=(node[s*2+1].mul*multiple)%p;
    node[s*2].add=(node[s*2].add*multiple+addup)%p;
    node[s*2+1].add=(node[s*2+1].add*multiple+addup)%p;
}
void insert(int s,int x,int y,long long multiple,long long addup)
{
    int mid;
    pushdown(s);
    int l=node[s].lson,r=node[s].rson;
    if (l==x && y==r)
      {
        node[s].value=(node[s].value*multiple+addup*(r-l+1))%p;
        node[s].mul=(node[s].mul*multiple)%p;
        node[s].add=(node[s].add*multiple+addup)%p;
        return;
      }
    mid=(l+r)/2;
    if (y<=mid)
      insert(s*2,x,y,multiple,addup);
    else
      if (x>mid)
        insert(s*2+1,x,y,multiple,addup);
      else
        {
            insert(s*2,x,mid,multiple,addup);
            insert(s*2+1,mid+1,y,multiple,addup);
        }
    update(s);
}
long long query(int s,int x,int y)
{
    int l=node[s].lson,r=node[s].rson,mid;
    long long ans;
    pushdown(s);
    if (l==x && y==r)
      return node[s].value;
    mid=(l+r)/2;
    if (y<=mid)
      ans=query(s*2,x,y);
    else
      if (x>mid)
        ans=query(s*2+1,x,y);
      else
        ans=(query(s*2,x,mid)+query(s*2+1,mid+1,y))%p;
    update(s);
    return ans;
}
int main()
{
    int i,m,q,x,y,z;
    n=read();
    p=read();
    for (i=1;i<=n;i++)
      a[i]=read();
    build(1,1,n);
    m=read();
    for (i=1;i<=m;i++)
      {
        q=read();
        if (q==1)
          {
            x=read();
            y=read();
            z=read();
            insert(1,x,y,z,0);
          }
        if (q==2)
          {
            x=read();
            y=read();
            z=read();
            insert(1,x,y,1,z);
          }
        if (q==3)
          {
            x=read();
            y=read();
            printf("%lld\n",query(1,x,y)%p);
          }
      }
    return 0;
}

  • 12
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Seq2seq模型是一种常用的序列序列模型,可用于机器翻译、语音识别等任务。以下是一个简单的Seq2seq模型代码示例: ```python import numpy as np import tensorflow as tf # 输入序列长度 encoder_seq_length = 20 # 输出序列长度 decoder_seq_length = 10 # 批大小 batch_size = 32 # 词汇表大小 vocab_size = 10000 # 隐层维度 hidden_size = 128 # 定义输入 encoder_inputs = tf.placeholder(shape=(None, encoder_seq_length), dtype=tf.int32, name='encoder_inputs') decoder_inputs = tf.placeholder(shape=(None, decoder_seq_length), dtype=tf.int32, name='decoder_inputs') decoder_targets = tf.placeholder(shape=(None, decoder_seq_length), dtype=tf.int32, name='decoder_targets') # 定义编码器 encoder_emb = tf.Variable(tf.random_uniform([vocab_size, hidden_size], -1.0, 1.0), dtype=tf.float32) encoder_inputs_emb = tf.nn.embedding_lookup(encoder_emb, encoder_inputs) encoder_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=hidden_size) _, encoder_state = tf.nn.dynamic_rnn(cell=encoder_cell, inputs=encoder_inputs_emb, dtype=tf.float32) # 定义解码器 decoder_emb = tf.Variable(tf.random_uniform([vocab_size, hidden_size], -1.0, 1.0), dtype=tf.float32) decoder_inputs_emb = tf.nn.embedding_lookup(decoder_emb, decoder_inputs) decoder_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=hidden_size) decoder_outputs, _ = tf.nn.dynamic_rnn(cell=decoder_cell, inputs=decoder_inputs_emb, initial_state=encoder_state, dtype=tf.float32) # 定义输出层 decoder_outputs_flat = tf.reshape(decoder_outputs, [-1, hidden_size]) decoder_logits_flat = tf.layers.dense(decoder_outputs_flat, units=vocab_size, name='decoder_dense') decoder_logits = tf.reshape(decoder_logits_flat, [-1, decoder_seq_length, vocab_size]) # 定义损失函数和优化器 cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=decoder_targets, logits=decoder_logits) loss = tf.reduce_mean(cross_entropy) optimizer = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss) # 训练模型 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(1000): encoder_inputs_batch = np.random.randint(low=0, high=vocab_size, size=(batch_size, encoder_seq_length)) decoder_inputs_batch = np.random.randint(low=0, high=vocab_size, size=(batch_size, decoder_seq_length)) decoder_targets_batch = decoder_inputs_batch[:, 1:] feed_dict = { encoder_inputs: encoder_inputs_batch, decoder_inputs: decoder_inputs_batch, decoder_targets: decoder_targets_batch } _, loss_value = sess.run([optimizer, loss], feed_dict=feed_dict) if i % 100 == 0: print('Iteration %d, loss = %.4f' % (i, loss_value)) ``` 在上面的代码中,我们首先定义了输入的占位符,然后定义了编码器和解码器的模型。编码器将输入序列转换为一个固定长度的向量,解码器则将这个向量作为初始状态,并生成输出序列。最后,我们定义了损失函数和优化器,以及训练过程。 需要注意的是,上面的代码只是一个简单的示例,实际应用中可能需要进行更复杂的模型设计和调整。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值