Submission #2403423

---

Source Code Expand

use std::env;
use std::io::*;
use std::str::*;
use std::mem;
use std::collections::HashMap;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin.bytes().map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}
fn read_char() -> char {
    let c = read::<String>();
    let c = c.chars().collect::<Vec<char>>();
    c[0]
}
fn read_String_Vec() -> Vec<char> {
    let S = read::<String>();
    S.chars().collect::<Vec<char>>()
}

fn vecchar_to_String(Vs: &Vec<char>) -> String {
    let mut S = String::new();
    for i in 0..Vs.len() {
        S.push(Vs[i]);
    }
    S
}

/*
文字コード
A : 65
Z : 90
a : 97
z : 122
0 : 48
9 : 57
*/

/*
let N = read::<i32>();
let S = read::<String>();
let S = read_String_Vec();
let C = read_char();
*/

/*
 .to_string() : * -> String
 &*S          : String -> &str
*/

fn min(can1: i32, can2: i32, can3: i32) -> i32 {
    if can1 < can2 {
        if can1 < can3 {
            can1
        } else {
            can3
        }
    } else {
        if can2 < can3 {
            can2
        }  else {
            can3
        }
    }
}

fn main() {
    // main の引数
    /*
        引数なしのときargs.len() = 1;
    */
    let args: Vec<String> = env::args().collect();


    let N = read::<i32>();
    let H = read::<i32>();
    let A = read::<i32>();
    let B = read::<i32>();
    let C = read::<i32>();
    let D = read::<i32>();
    let E = read::<i32>();

    //let mut x;
    let mut y;
    let mut cost = <i32>::max_value();
    let mut cost_tmp = 0;

    let mut xmin = ((E*N-H) as f64 / (B + E) as f64).ceil() as i32;
    let mut ymin = ((E*N-H) as f64 / (D + E) as f64).ceil() as i32;
    println!("xmin : {}", xmin);
    println!("ymin : {}", ymin);


    for x in 0..xmin+1 {
        y = ((E*N-H-(B+E)*x) as f64 / (D + E) as f64).ceil() as i32;
        if y < 0 {
            y = 0;
        }
        if x+y > N || H - E*N + (B+E)*x + (D+E)*y <= 0 {
            continue;
        }
         cost_tmp = A*x + C*y;
        if cost_tmp < cost {
            cost = cost_tmp;
            //println!("x : {}, y : {}", x, y);
        }
    }

    let mut x = 0;
    for y in 0..ymin+1 {
        x = ((E*N-H-(D+E)*x) as f64 / (B + E) as f64).ceil() as i32;
        if x < 0 {
            x = 0;
        }
        if x+y > N || H - E*N + (B+E)*x + (D+E)*y <= 0 {
            continue;
        }
        cost_tmp = A*x + C*y;
        if cost_tmp < cost {
           cost = cost_tmp;
           //println!("x : {}, y : {}", x, y);
        }
    }
    println!("{}", cost);
}

Submission Info

Compile Error

warning: unused import: `std::mem`, #[warn(unused_imports)] on by default
 --> ./Main.rs:4:5
  |
4 | use std::mem;
  |     ^^^^^^^^

warning: unused import: `std::collections::HashMap`, #[warn(unused_imports)] on by default
 --> ./Main.rs:5:5
  |
5 | use std::collections::HashMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: function is never used: `read_char`, #[warn(dead_code)] on by default
  --> ./Main.rs:15:1
   |
15 |   fn read_char() -> char {
   |  _^ starting here...
16 | |     let c = read::<String>();
17 | |     let c = c.chars().collect::<Vec<char>>();
18 | |     c[0]
19 | | }
   | |_^ ...ending here

warning: function is never used: `read_String_Vec`, #[warn(dead_code)] on by default
  --> ./Main.rs:20:1
   |
20 |   fn read_String_Vec() -> Vec<char> {
   |  _^ starting here...
21 | |     let S = read::<String>();
22 | |     S.chars().collect::<Vec<char>>()
23 | | }
   | |_^ ...ending here

warning: function `read_String_Vec` should have a snake case name such as `read_string_vec`, #[war...

Judge Result