package 回合制游戏;

import java.util.Scanner;

/*
 * 你在玩一个回合制角色扮演的游戏。
 * 现在你在准备一个策略，以便在最短的回合内击败敌方角色。
 * 在战斗开始时，敌人拥有HP格血量。当血量小于等于0时，敌人死去。
 * 一个缺乏经验的玩家可能简单地尝试每个回合都攻击。但是你知道辅助技能的重要性。
 * 在你的每个回合开始时你可以选择以下两个动作之一：聚力或者攻击。
 * 聚力会提高你下个回合攻击的伤害。
 * 攻击会对敌人造成一定量的伤害。如果你上个回合使用了聚力，那这次攻击会对敌人造成buffedAttack点伤害。
 * 否则，会造成normalAttack点伤害。
 * 给出血量HP和不同攻击的伤害，buffedAttack和normalAttack，返回你能杀死敌人的最小回合数。
 * 
 * 输入描述:
 * 第一行是一个数字HP
 * 第二行是一个数字normalAttack
 * 第三行是一个数字buffedAttack
 * 1 <= HP,buffedAttack,normalAttack <= 10^9
 * 
 * 输出描述:
 * 输出一个数字表示最小回合数
 * 
 * 输入例子1:
 * 13
 * 3
 * 5
 * 
 * 输出例子1:
 * 5
 */
/*
 * 算法：贪心
 * 数据结构：基本数据类型
 * 思路：如果buffedAttack <= 2 * normalAttack，则一直使用普通攻击；
 * 如果buffedAttack > 2 * normalAttack，一定优先使用加强攻击；
 * 若healthPoint % 2 != 0，则存在最后一击的选择；
 * 最后一击<=normalAttack，则最后一击使用普通攻击，否则还是使用加强攻击。
 */
public class Main {
	
	//一直使用普通攻击时的回合数
	private static int getRoundAlwaysNormalAttack(int healthPoint, int normalAttack, int buffedAttack) {
		int round = 0;
		//向上取整
		if (healthPoint % normalAttack == 0) {
			round = healthPoint / normalAttack;
		}
		else {
			round = healthPoint / normalAttack + 1;
		}
		return round;
	}
	
	//优先使用加强攻击时的回合数
	private static int getRoundPriorityBuffedAttack(int healthPoint, int normalAttack, int buffedAttack) {
		int round = 0;
		//不存在最后一击的选择
		if (healthPoint % buffedAttack == 0) {
			round = 2 * (healthPoint / buffedAttack);
		}
		else if (healthPoint % buffedAttack <= normalAttack) {
			round = 2 * (healthPoint / buffedAttack) + 1;
		}
		else {
			//healthPoint / buffedAttack保证次数准确，不能被*2影响，最先运算
			round = 2 * (healthPoint / buffedAttack) + 2;
		}
		return round;
	}
	
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int healthPoint = input.nextInt();
		int normalAttack = input.nextInt();
		int buffedAttack = input.nextInt();
		input.close();
		
		int minRound = 0;
		if (buffedAttack <= 2 * normalAttack) {
			minRound = getRoundAlwaysNormalAttack(healthPoint, normalAttack, buffedAttack);
		}
		else {
			minRound = getRoundPriorityBuffedAttack(healthPoint, normalAttack, buffedAttack);
		}
		System.out.println(minRound);
	}
}

#include<stdio.h>
#include<iostream>
int main(){
    int HP,normalAttack,buffedAttack;
    scanf("%d",&HP);
    scanf("%d",&normalAttack);
    scanf("%d",&buffedAttack);
    int better=std::max(2*normalAttack,buffedAttack);
    int res=2*(HP/better);
    int remain=HP%better;

    res+=((int)(remain>normalAttack)+(int)(remain!=0));
    printf("%d",res);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main(){
    int HP,x,y,cnt=0;
    cin>>HP>>x>>y;
    if(HP<=x)
        cout<<1<<endl;
    else{
        if((x<<1)>=y){
            cnt = int(ceil(1.0*HP/x));
        }else{
            while(HP>x){
                HP -= y;
                cnt += 2;
            }
            if(HP>0)
                cnt++;
        }
        cout<<cnt<<endl;
    }
    return 0;
}

import math
def min_round(hp, norm, high):
    if norm * 2 >= high:
        return math.ceil(hp / norm)
    else:
        r = hp % high 
        if r == norm:
            return math.ceil(hp / high) * 2 - 1
        return math.ceil(hp / high) * 2

"""
分支判断
"""
import math

if __name__ == "__main__":
    hp = int(input().strip())
    normalAttack = int(input().strip())
    buffedAttack = int(input().strip())
    ans = 0
    if 2 * normalAttack >= buffedAttack:
        ans = math.ceil(hp / normalAttack)
    else:
        ans = math.floor(hp / buffedAttack) * 2
        hp = hp % buffedAttack
        if hp > 0:
            if hp <= normalAttack:
                ans += 1
            else:
                ans += 2
    print(ans)

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int hp,normalAttack,buffedAttack,res=0;
    cin>>hp;
    cin>>normalAttack;
    cin>>buffedAttack;
    if(normalAttack*2>buffedAttack)
    {
        if(hp%normalAttack==0)
            res=hp/normalAttack;
        else
            res=hp/normalAttack+1;
    }
    else
    {
        if(hp%buffedAttack==0)
            res=hp/buffedAttack*2;
        else if(hp%buffedAttack>normalAttack)
            res=hp/buffedAttack*2+2;
        else if(hp%buffedAttack<=normalAttack)
            res=hp/buffedAttack*2+1;
    }
    cout<<res<<endl;
    return 0;
}

#include<iostream>
using namespace std;
int main()
{ 
    int HP;
    cin >> HP;
    int nA, bA;
    cin >> nA;
    cin >> bA;
    int count = 0;
    if (HP <= nA) {
        cout << 1;
        return 0;
    }
    else {
        if (2 * nA >= bA) {//当蓄力的伤害不高于普通伤害的二倍的时候，全用普通伤害就行了
            while (HP > 0) {
                HP -= nA;
                count++;
            }
        }
        else {//当蓄力的伤害高于普通伤害的二倍的时候,尽可能多打蓄力伤害，判断最后是不是只需打一次普通伤害就行了
            while (HP > nA) {
                HP -= bA;
                count += 2;
            }
            if (HP > 0) count++;
        }
    }
    cout << count;
    return 0;
}

刚刚写的博客，同步到牛客一下~https://blog.csdn.net/weixin_39350124/article/details/91345870

解法1（深度优先搜索）

（case通过率只有75%，想AC的可以直接看解法2）
用一个int变量buffed，当buffed=1表示buffedAttack，buffed=0表示normalAttack，然后每次进入递归方法都有两种决策方式。具体Code如下所示：

import java.util.HashMap;
import java.util.Scanner;

public class Main {

    public static HashMap<String, Integer> map = new HashMap<>(); //用于记忆化搜索

    /**
     * @param hp 当前hp
     * @param normalAttack 普通攻击
     * @param buffedAttack 辅助攻击
     * @param isBuffed 本回合是否使用辅助攻击
     * @param cur 当前回合数
     * @return
     */
    public static int process(int hp, int normalAttack, int buffedAttack, int isBuffed, int cur) {
        String str = isBuffed + "_" + hp; //用isBuffed和hp作为记忆化搜索的key

        //每次进入递归之前先搜索是否有缓存结果
        if (map.containsKey(str)) {
            return map.get(str);
        }
        //如果hp < 1,返回需要的回合
        if (hp < 1) {
            map.put(str, cur); //返回结果前加缓存
            return cur;
        }

        int res = 0;
        if (isBuffed == 1) {
            //如果上回合用buffedAttack，则这回合直接减去敌人生命值
            res = process(hp - buffedAttack, normalAttack, buffedAttack, 0, cur + 1);
        } else {
            //如果上回合使用normalAttack，则这回合有两种决策方式
            res = Math.min(process(hp - normalAttack, normalAttack, buffedAttack, 0, cur + 1),
                    process(hp, normalAttack, buffedAttack, 1, cur + 1));
        }
        map.put(str, res); //返回结果前加缓存
        return res;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int hp = sc.nextInt();
        int normal = sc.nextInt();
        int buffed = sc.nextInt();
        //一开始有两种选择
        int a = process(hp, normal, buffed, 1, 1); //蓄力
        int b = process(hp - normal, normal, buffed, 0, 1); //普通攻击
        System.out.println(Math.min(a, b));
    }
}

解法2（数学规律）

直接用数学规律去分析：
1）如果buffedAttack <= 2 * normalAttack，那么一定全程使用normalAttack更划算
2）如果buffedAttack > 2 * normalAttack，那么优先使用buffedAttack更划算，如果hp % normalAttack > 0，当余数小于normalAttack，最后一回合用normalAttack就能杀死敌人；如果hp % normalAttack == 0，那么一定全程使用buffedAttack更划算。
具体Code如下：

import java.util.Scanner;

public class Main {

    public static int func(int hp, int normalAttack, int buffedAttack) {
        int res = 0;
        /**
         * 如果buffedAttack > 2 * normalAttack，那么一定优先使用buffedAttack划算
         */
        if (buffedAttack > 2 * normalAttack) {
            res = hp % buffedAttack;
            /**
             * 如果hp % normalAttack > 0
             * 当余数小于normalAttack，最后一回合用normalAttack就能杀死敌人
             * 其它情况，一直使用buffedAttack攻击
             */
            if (res > 0 && res <= normalAttack) {
                res = (hp / buffedAttack) * 2 + 1;
            } else {
                res = ((hp - 1) / buffedAttack) * 2 + 2;
            }
        } else {
            /**
             * 如果buffedAttack <= 2 * normalAttack，一直单回合普通攻击更划算
             */
            res = (hp - 1) / normalAttack + 1;
        }
        return res;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int hp = sc.nextInt();
        int normal = sc.nextInt();
        int buffed = sc.nextInt();
        System.out.println(func(hp, normal, buffed));
    }
}

#include <bits/stdc++.h>
using namespace std;
int main(){
    int hp,NAtk,BAtk,sum=0;
    cin>>hp>>NAtk>>BAtk;
    if(hp<=NAtk)
        sum++;
    else if(hp<=BAtk)
        sum+=2;
    else if(2*NAtk>=BAtk){
        sum=hp/NAtk;
        if(hp%NAtk)
            sum++;
    }
    else{
        sum=hp/BAtk;
        int t=hp%BAtk;
        if(t!=0&&t<=NAtk)
            sum++;
        else if(t>NAtk)
            sum+=2;
    }
    cout<<sum;
    return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;

signed main(){
    int s, a, b;
    cin >> s >> a >> b;
    if(a * 2 >= b){
        int ans = s / a + !!(s % a);
        cout << ans << endl;
    }
    else{
        int ans = s / b * 2;
        int t = s % b;
        if(t == 0) cout << ans << endl;
        else if(a >= t) cout << ans + 1 << endl;
        else cout << ans + 2 << endl;
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int hp = in.nextInt();
            int na = in.nextInt();
            int ba = in.nextInt();
            //
            boolean flag = false;
            if (ba > 2 * na)flag = true;
            // 如果蓄力两回合还不如不蓄力
            if (!flag) {
                int n = hp / na;
                int m = hp % na;
                if (m > 0) {
                    n++;
                }
                System.out.print(n);
            } else {
                for (int i = 1;; i++) {
                    if (i % 2 == 1) {
                        if (hp <= na) {
                            System.out.print(i);
                            break;
                        } else {
                            hp -= 0;
                        }
                    } else {
                        hp -= ba;
                    }
                    if (hp <= 0) {
                        System.out.print(i);
                        break;
                    }
                }
            }
        }
    }
}

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,a,b;cin>>n>>a>>b;
    if(b<=a*2)
    {
        if(n%a==0)    {cout<<n/a<<endl;return 0;}
        else {cout<<n/a+1<<endl;return 0;}
    }
    else
    {
        int sum=n/b*2;
        if(n-sum/2*b==0)    {cout<<sum<<endl;return 0;}
        else
        {
            int sum1=0,m=n-sum/2*b;
            while(m>0)
            {
                m-=a;sum1++;
            }
            cout<<min(sum1+sum,sum+2)<<endl;
        }
    }
    return 0;
}

#include <stdio.h>

int main()
{
    int HP, normalAttack, buffedAttack;
    int count = 0;
    scanf("%d\n%d\n%d", &HP, &normalAttack, &buffedAttack);
    //如果攻击大于敌方血量，则只需要一回合。
    if(HP < normalAttack)
        count = 1;
    //如果聚力大于敌方血量，则只需要两回合。
    else if(HP < buffedAttack)
        count = 2;
    //如果两倍的攻击大于聚力，则每一回合都使用攻击。否则使用聚力。
    else if(2*normalAttack >= buffedAttack)
    {
        count = HP/normalAttack;
        if(HP%normalAttack)
            count++;
    }
    else
    {
        count = HP/buffedAttack*2;
        int rem = HP%buffedAttack;
        //最后一回合敌人剩余的血量不为0，且小于攻击，则选择攻击；否则选择聚力。
        if(rem != 0 && rem <= normalAttack)
            count++;
        else if(rem > normalAttack)
            count+=2;
    }
    printf("%d", count);
    return 0;
}