สนิม929 923 ตัวอักษร
use std::io;use std::str::FromStr;static C:&'static [i32]=&[-2,-1,2,5,10,15];fn main(){let mut z=String::new();io::stdin().read_line(&mut z).unwrap();let n=(&z.trim()[..]).split(' ').map(|e|i32::from_str(e).unwrap()).collect::<Vec<i32>>();let l=*n.iter().min().unwrap();let x=n.iter().max().unwrap()-if l>1{1}else{l};let s=g(x as usize);println!("{}",p(1,n,&s));}fn g(x:usize)->Vec<i32>{let mut s=vec![std::i32::MAX-9;x];for c in C{if *c>0&&(*c as usize)<=x{s[(*c-1)as usize]=1;}}let mut i=1us;while i<x{let mut k=i+1;for c in C{if(i as i32)+*c<0{continue;}let j=((i as i32)+*c)as usize;if j<x&&s[j]>s[i]+1{s[j]=s[i]+1;if k>j{k=j;}}}i=k;}s}fn p(r:i32,n:Vec<i32>,s:&Vec<i32>)->i32{if n.len()==1{h(r,n[0],&s)}else{(0..n.len()).map(|i|{let mut m=n.clone();let q=m.remove(i);p(q,m,&s)+h(r,q,&s)}).min().unwrap()}}fn h(a:i32,b:i32,s:&Vec<i32>)->i32{if a==b{0}else if a>b{((a-b)as f32/2f32).ceil()as i32}else{s[(b-a-1)as usize]}}
สนุกมาก!
ความเห็นเกี่ยวกับการดำเนินการ
เห็นได้ชัดว่าฉันไม่ได้มีความสุขกับขนาด แต่สนิมนั้นยอดเยี่ยมมากในการเล่นกอล์ฟ อย่างไรก็ตามการแสดงนั้นยอดเยี่ยมมาก
รหัสแก้ปัญหาแต่ละกรณีการทดสอบอย่างถูกต้องในระยะเวลาอันใกล้ดังนั้นประสิทธิภาพจึงไม่เป็นปัญหา เพื่อความสนุกนี่เป็นกรณีทดสอบที่ยากกว่านี้มาก:
1234567 123456 12345 1234 123 777777 77777 7777 777
ซึ่งคำตอบคือ82317โปรแกรมของฉันสามารถแก้ไขบนแล็ปท็อปของฉัน (ประสิทธิภาพปานกลาง) ใน1.66 วินาที (!) แม้จะใช้อัลกอริธึมเส้นทาง Hamiltonian ที่โหดร้ายแบบเรียกซ้ำ
ข้อสังเกต
ก่อนอื่นเราควรสร้างกราฟถ่วงน้ำหนักที่มีการปรับเปลี่ยนโดยโหนดต่างๆเป็นหมายเลข "โชคดี" และน้ำหนักเป็นจำนวนการเปลี่ยนแปลงที่ต้องได้รับจากระดับชื่อเสียงหนึ่งไปสู่อีกระดับ แต่ละคู่ของโหนดจะต้องเชื่อมต่อด้วยสองขอบเนื่องจากการขึ้นไปนั้นไม่เหมือนกับการลงในค่าชื่อเสียง (คุณสามารถรับ +10 ตัวอย่างเช่น แต่ไม่ใช่ -10)
ตอนนี้เราต้องหาวิธีหาจำนวนการเปลี่ยนแปลงขั้นต่ำจากค่าตัวแทนหนึ่งไปสู่อีกค่า
สำหรับการเดินทางจากมูลค่าที่สูงกว่าเป็นค่าที่ต่ำกว่ามันง่าย: เพียงแค่ใช้เวลาceil((a - b) / 2)ที่aเป็นค่าที่สูงขึ้นและbเป็นค่าที่ต่ำกว่า ตัวเลือกเชิงตรรกะเพียงอย่างเดียวของเราคือการใช้ -2 ให้มากที่สุดจากนั้นเลือก -1 เพียงครั้งเดียวหากจำเป็น
ค่าต่ำถึงสูงนั้นซับซ้อนกว่าเล็กน้อยเนื่องจากการใช้ค่าสูงสุดที่เป็นไปได้นั้นอาจไม่เหมาะสมเสมอไป (เช่นสำหรับ 0 ถึง 9 ทางออกที่ดีที่สุดคือ +10 -1) อย่างไรก็ตามนี่เป็นปัญหาการเขียนโปรแกรมแบบไดนามิกของตำราเรียนและ DP แบบง่ายก็เพียงพอที่จะแก้ปัญหาได้
เมื่อเราคำนวณการเปลี่ยนแปลงขั้นต่ำจากแต่ละหมายเลขเป็นตัวเลขอื่น ๆ แล้วเราจะเหลือส่วนต่างของ TSP เล็กน้อย (ปัญหาพนักงานขายเดินทาง) โชคดีที่มีจำนวนโหนดน้อยมาก (สูงสุด 5 ในกรณีทดสอบที่ยากที่สุด) ที่แรงเดรัจฉานก็เพียงพอสำหรับขั้นตอนนี้
รหัสที่ไม่ได้รับการตอบรับ (มีการแสดงความคิดเห็นอย่างมาก)
use std::io;
use std::str::FromStr;
// all possible rep changes
static CHANGES: &'static [i32] = &[-2, -1, 2, 5, 10, 15];
fn main() {
// read line of input, convert to i32 vec
let mut input = String::new();
io::stdin().read_line(&mut input).unwrap();
let nums = (&input.trim()[..]).split(' ').map(|x| i32::from_str(x).unwrap())
.collect::<Vec<i32>>();
// we only need to generate as many additive solutions as max(nums) - min(nums)
// but if one of our targets isn't 1, this will return a too-low value.
// fortunately, this is easy to fix as a little hack
let min = *nums.iter().min().unwrap();
let count = nums.iter().max().unwrap() - if min > 1 { 1 } else { min };
let solutions = generate_solutions(count as usize);
// bruteforce!
println!("{}", shortest_path(1, nums, &solutions));
}
fn generate_solutions(count: usize) -> Vec<i32> {
let mut solutions = vec![std::i32::MAX - 9; count];
// base cases
for c in CHANGES {
if *c > 0 && (*c as usize) <= count {
solutions[(*c-1) as usize] = 1;
}
}
// dynamic programming! \o/
// ok so here's how the algorithm works.
// we go through the array from start to finish, and update the array
// elements at i-2, i-1, i+2, i+5, ... if solutions[i]+1 is less than
// (the corresponding index to update)'s current value
// however, note that we might also have to update a value at a lower index
// than i (-2 and -1)
// in that case, we will have to go back that many spaces so we can be sure
// to update *everything*.
// so for simplicity, we just set the new index to be the lowest changed
// value (and increment it if there were none changed).
let mut i = 1us; // (the minimum positive value in CHANGES) - 1 (ugly hardcoding)
while i < count {
let mut i2 = i+1;
// update all rep-values reachable in 1 "change" from this rep-value,
// by setting them to (this value + 1), IF AND ONLY IF the current
// value is less optimal than the new value
for c in CHANGES {
if (i as i32) + *c < 0 { continue; } // negative index = bad
let idx = ((i as i32) + *c) as usize; // the index to update
if idx < count && solutions[idx] > solutions[i]+1 {
// it's a better solution! :D
solutions[idx] = solutions[i]+1;
// if the index from which we'll start updating next is too low,
// we need to make sure the thing we just updated is going to,
// in turn, update other things from itself (tl;dr: DP)
if i2 > idx { i2 = idx; }
}
}
i = i2; // update index (note that i2 is i+1 by default)
}
solutions
}
fn shortest_path(rep: i32, nums: Vec<i32>, solutions: &Vec<i32>) -> i32 {
// mercifully, all the test cases are small enough so as to not require
// a full-blown optimized traveling salesman implementation
// recursive brute force ftw! \o/
if nums.len() == 1 { count_changes(rep, nums[0], &solutions) } // base case
else {
// try going from 'rep' to each item in 'nums'
(0..nums.len()).map(|i| {
// grab the new rep value out of the vec...
let mut nums2 = nums.clone();
let new_rep = nums2.remove(i);
// and map it to the shortest path if we use that value as our next target
shortest_path(new_rep, nums2, &solutions) + count_changes(rep, new_rep, &solutions)
}).min().unwrap() // return the minimum-length path
}
}
fn count_changes(start: i32, finish: i32, solutions: &Vec<i32>) -> i32 {
// count the number of changes required to get from 'start' rep to 'finish' rep
// obvious:
if start == finish { 0 }
// fairly intuitive (2f32 is just 2.0):
else if start > finish { ((start - finish) as f32 / 2f32).ceil() as i32 }
// use the pregenerated lookup table for these:
else /* if finish > start */ { solutions[(finish - start - 1) as usize] }
}
<!-- language-all: lang-rust -->และเช่นเดียวกับหัวขึ้นคุณจะได้รับการเน้นไวยากรณ์ด้วย ;)